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
"); }); initialize(); run_test("get_people_for_stream_create", () => { people.add_active_user(alice1); people.add_active_user(bob); people.add_active_user(alice2); assert.equal(people.get_active_human_count(), 4); const others = people.get_people_for_stream_create(); const expected = [ {email: "alice1@example.com", user_id: alice1.user_id, full_name: "Alice"}, {email: "alice2@example.com", user_id: alice2.user_id, full_name: "Alice"}, {email: "bob@example.com", user_id: bob.user_id, full_name: "Bob van Roberts"}, ]; assert.deepEqual(others, expected); }); initialize(); run_test("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); }); run_test("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_people_for_stream_create(); let filtered_people = people.filter_people_by_search_terms(users, [search_term]); assert.equal(filtered_people.size, 2); assert(filtered_people.has(ashton.user_id)); assert(filtered_people.has(maria.user_id)); assert(!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(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(filtered_people.has(charles.user_id)); assert(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(filtered_people.has(noah.user_id)); assert(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(filtered_people.has(noah.user_id)); // Test filtering with undefined user users.push(unknown_user); filtered_people = people.filter_people_by_search_terms(users, ["ltorv"]); assert.equal(filtered_people.size, 1); assert(filtered_people.has(linus.user_id)); }); people.init(); run_test("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); }); initialize(); run_test("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"); }); initialize(); run_test("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.deepEqual(people.sender_info_with_small_avatar_urls_for_sender_ids([30]), [ { avatar_url_small: "/avatar/30&s=50", email: "me@example.com", full_name: "Me the Third", is_admin: false, is_bot: false, is_guest: false, profile_data: { 3: { rendered_value: "Field value
", value: "Field value", }, }, 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/pm-with/301,302-group"); assert.equal(people.pm_perma_link(message), "#narrow/pm-with/30,301,302-group"); assert.equal(people.pm_reply_to(message), "Athens@example.com,charles@example.com"); assert.equal(people.small_avatar_url(message), "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/pm-with/302-athens"); assert.equal(people.pm_perma_link(message), "#narrow/pm-with/30,302-pm"); assert.equal(people.pm_reply_to(message), "Athens@example.com"); assert.equal(people.small_avatar_url(message), "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 get_by_user_id: 9999999"); 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), `/avatar/${ashton.user_id}&s=50`); message = { type: "private", display_recipient: [{id: me.user_id}], }; assert.equal(people.pm_with_url(message), "#narrow/pm-with/30-me"); assert.equal(people.pm_perma_link(message), "#narrow/pm-with/30-pm"); 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); }); initialize(); run_test("extract_people_from_message", () => { let message = { type: "stream", sender_full_name: maria.full_name, sender_id: maria.user_id, sender_email: maria.email, }; assert(!people.is_known_user_id(maria.user_id)); let reported; people.__Rewire__("report_late_add", (user_id, email) => { assert.equal(user_id, maria.user_id); assert.equal(email, maria.email); reported = true; }); people.extract_people_from_message(message); assert(people.is_known_user_id(maria.user_id)); assert(reported); // Get line coverage people.__Rewire__("report_late_add", () => { throw new Error("unexpected late add"); }); message = { type: "private", display_recipient: [unknown_user], }; people.extract_people_from_message(message); }); initialize(); run_test("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 unknown_recip = { email: "unknown@example.com", id: 500, unknown_local_echo_user: true, }; message = { type: "private", sent_by_me: true, display_recipient: [unknown_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); }); run_test("slugs", () => { people.add_active_user(debbie); const slug = people.emails_to_slug(debbie.email); assert.equal(slug, "501-debbie71"); 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); }); initialize(); run_test("get_people_for_search_bar", () => { message_store.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); } const big_results = people.get_people_for_search_bar("James"); assert.equal(big_results.length, 20); message_store.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_store, we will get a small result and not // search all people. assert.equal(small_results.length, 6); }); initialize(); run_test("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(!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(!people.is_cross_realm_email(new_email)); const all_people = get_all_persons(); assert.equal(all_people.length, 2); 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); }); initialize(); run_test("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, unknown@example.com"; assert.equal(people.update_email_in_reply_to(reply_to, 9999, "whatever"), reply_to); }); initialize(); run_test("track_duplicate_full_names", () => { people.add_active_user(maria); people.add_active_user(stephen1); assert(!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(people.is_duplicate_full_name("Stephen King")); assert(!people.is_duplicate_full_name("Maria Athens")); assert(!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(!people.is_duplicate_full_name("Stephen King")); assert(!people.is_duplicate_full_name("Stephen King JP")); }); initialize(); run_test("get_mention_syntax", () => { people.add_active_user(stephen1); people.add_active_user(stephen2); people.add_active_user(maria); assert(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**"); }); run_test("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(people.is_cross_realm_email("bot@example.com")); assert(people.is_valid_email_for_compose("bot@example.com")); assert(people.is_valid_email_for_compose("alice@example.com")); assert(!people.is_valid_email_for_compose("retiree@example.com")); assert(!people.is_valid_email_for_compose("totally-bogus-username@example.com")); assert(people.is_valid_bulk_emails_for_compose(["bot@example.com", "alice@example.com"])); assert(!people.is_valid_bulk_emails_for_compose(["not@valid.com", "alice@example.com"])); assert(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); }); run_test("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]); }); run_test("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); set_email_visibility(everyone); page_params.is_admin = false; assert.equal(match({delivery_email: "fred@example.com"}, "fr"), false); assert.equal(match({email: "fred@example.com"}, "fr"), true); // 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({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({email: "fred@example.com"}, "re"), true); assert.equal(match({full_name: "Fred Smith"}, "re"), true); assert.equal(match({full_name: "Joe Frederick"}, "re"), true); }); initialize(); run_test("is_valid_full_name_and_user_id", () => { assert(!people.is_valid_full_name_and_user_id("bogus", 99)); assert(!people.is_valid_full_name_and_user_id(me.full_name, 99)); assert(people.is_valid_full_name_and_user_id(me.full_name, me.user_id)); }); run_test("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: dummyuser@example.com"); user_ids = people.emails_strings_to_user_ids_array("dummyuser@example.com"); assert.equal(user_ids, undefined); }); run_test("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); }); run_test("get_active_message_people", () => { message_store.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]); });