mirror of
https://github.com/zulip/zulip.git
synced 2026-06-24 21:08:25 +08:00
e64059de79
For all the places where we just make zero or one blueslip call, asserting for length is either unnecessary or overkill.
1063 lines
32 KiB
JavaScript
1063 lines
32 KiB
JavaScript
zrequire('people');
|
|
set_global('message_store', {});
|
|
set_global('page_params', {});
|
|
set_global('settings_data', {});
|
|
set_global('md5', function (s) {
|
|
return 'md5-' + s;
|
|
});
|
|
|
|
const settings_config = zrequire('settings_config');
|
|
const visibility = settings_config.email_address_visibility_values;
|
|
const admins_only = visibility.admins_only.code;
|
|
const everyone = visibility.everyone.code;
|
|
|
|
function set_email_visibility(code) {
|
|
page_params.realm_email_address_visibility = code;
|
|
}
|
|
|
|
set_email_visibility(admins_only);
|
|
|
|
const welcome_bot = {
|
|
email: '[email protected]',
|
|
user_id: 4,
|
|
full_name: 'Welcome Bot',
|
|
is_bot: true,
|
|
// cross realm bots have no owner
|
|
};
|
|
|
|
const me = {
|
|
email: '[email protected]',
|
|
user_id: 30,
|
|
full_name: 'Me Myself',
|
|
timezone: 'US/Pacific',
|
|
is_admin: false,
|
|
is_guest: false,
|
|
is_bot: false,
|
|
};
|
|
|
|
const isaac = {
|
|
email: '[email protected]',
|
|
delivery_email: '[email protected]',
|
|
user_id: 32,
|
|
full_name: 'Isaac Newton',
|
|
};
|
|
|
|
function initialize() {
|
|
people.init();
|
|
people.add(me);
|
|
people.initialize_current_user(me.user_id);
|
|
}
|
|
|
|
initialize();
|
|
|
|
function get_all_persons() {
|
|
return people.filter_all_persons(() => true);
|
|
}
|
|
|
|
run_test('basics', () => {
|
|
const persons = get_all_persons();
|
|
|
|
assert.deepEqual(people.get_realm_users(), [me]);
|
|
|
|
assert.equal(persons.length, 1);
|
|
assert.equal(persons[0].full_name, 'Me Myself');
|
|
|
|
let realm_persons = people.get_realm_users();
|
|
assert.equal(realm_persons[0].full_name, 'Me Myself');
|
|
|
|
realm_persons = people.get_realm_users();
|
|
assert.equal(realm_persons.length, 1);
|
|
assert.equal(people.get_active_human_count(), 1);
|
|
|
|
const full_name = 'Isaac Newton';
|
|
const email = '[email protected]';
|
|
|
|
assert(!people.is_known_user_id(32));
|
|
assert(!people.is_valid_full_name_and_user_id(full_name, 32));
|
|
assert.equal(people.get_user_id_from_name(full_name), undefined);
|
|
|
|
people.add(isaac);
|
|
|
|
assert.equal(
|
|
people.get_actual_name_from_user_id(32),
|
|
full_name
|
|
);
|
|
|
|
assert(people.is_valid_full_name_and_user_id(full_name, 32));
|
|
assert(people.is_known_user_id(32));
|
|
assert.equal(people.get_active_human_count(), 2);
|
|
|
|
assert.equal(people.get_user_id_from_name(full_name), 32);
|
|
|
|
let person = people.get_by_email(email);
|
|
assert.equal(person.full_name, full_name);
|
|
|
|
person = people.get_active_user_for_email('[email protected]');
|
|
assert(!person);
|
|
|
|
person = people.get_active_user_for_email(email);
|
|
assert.equal(person.email, email);
|
|
|
|
realm_persons = people.get_realm_users();
|
|
assert.equal(realm_persons.length, 2);
|
|
|
|
const active_user_ids = people.get_active_user_ids().sort();
|
|
assert.deepEqual(active_user_ids, [me.user_id, isaac.user_id]);
|
|
assert.equal(people.is_active_user_for_popover(isaac.user_id), true);
|
|
assert(people.is_valid_email_for_compose(isaac.email));
|
|
|
|
// Now deactivate isaac
|
|
people.deactivate(isaac);
|
|
person = people.get_active_user_for_email(email);
|
|
assert(!person);
|
|
assert.equal(people.get_active_human_count(), 1);
|
|
assert.equal(people.is_active_user_for_popover(isaac.user_id), false);
|
|
assert.equal(people.is_valid_email_for_compose(isaac.email), false);
|
|
|
|
const bot_botson = {
|
|
email: '[email protected]',
|
|
user_id: 35,
|
|
full_name: 'Bot Botson',
|
|
is_bot: true,
|
|
bot_owner_id: isaac.user_id,
|
|
};
|
|
people.add(bot_botson);
|
|
assert.equal(people.is_active_user_for_popover(bot_botson.user_id), true);
|
|
|
|
assert.equal(
|
|
people.get_bot_owner_user(bot_botson).full_name,
|
|
'Isaac Newton'
|
|
);
|
|
|
|
// Add our cross-realm bot. It won't add to our human
|
|
// count, and it has no owner.
|
|
people._add_user(welcome_bot);
|
|
assert.equal(people.get_bot_owner_user(welcome_bot), undefined);
|
|
assert.equal(people.get_active_human_count(), 1);
|
|
assert.equal(
|
|
people.get_by_email(welcome_bot.email).full_name,
|
|
'Welcome Bot'
|
|
);
|
|
|
|
// get_realm_users() will include our active bot,
|
|
// but will exclude isaac (who is deactivated)
|
|
assert.deepEqual(
|
|
people.get_realm_users().map((u) => u.user_id).sort(),
|
|
[
|
|
me.user_id,
|
|
bot_botson.user_id,
|
|
]
|
|
);
|
|
|
|
// The bot doesn't add to our human count.
|
|
assert.equal(people.get_active_human_count(), 1);
|
|
|
|
// Invalid user ID returns false and warns.
|
|
blueslip.expect('warn', 'Unexpectedly invalid user_id in user popover query: 123412');
|
|
assert.equal(people.is_active_user_for_popover(123412), false);
|
|
blueslip.reset();
|
|
|
|
// We can still get their info for non-realm needs.
|
|
person = people.get_by_email(email);
|
|
assert.equal(person.email, email);
|
|
|
|
// The current user should still be there
|
|
person = people.get_by_email('[email protected]');
|
|
assert.equal(person.full_name, 'Me Myself');
|
|
|
|
// Test undefined people
|
|
assert.equal(people.is_cross_realm_email('[email protected]'), undefined);
|
|
assert.equal(people.get_active_user_for_email('[email protected]'), undefined);
|
|
|
|
// Test is_my_user_id function
|
|
assert.equal(people.is_my_user_id(me.user_id), true);
|
|
assert.equal(people.is_my_user_id(isaac.user_id), false);
|
|
assert.equal(people.is_my_user_id(undefined), false);
|
|
|
|
// Reactivating issac
|
|
people.add(isaac);
|
|
const active_humans = people.get_active_humans();
|
|
assert.equal(active_humans.length, 2);
|
|
assert.deepEqual(
|
|
active_humans.sort((p) => p.user_id),
|
|
[me, isaac]);
|
|
});
|
|
|
|
run_test('pm_lookup_key', () => {
|
|
assert.equal(people.pm_lookup_key('30'), '30');
|
|
assert.equal(people.pm_lookup_key('32,30'), '32');
|
|
assert.equal(people.pm_lookup_key('101,32,30'), '32,101');
|
|
});
|
|
|
|
run_test('get_recipients', () => {
|
|
assert.equal(people.get_recipients('30'), 'Me Myself');
|
|
assert.equal(people.get_recipients('30,32'), 'Isaac Newton');
|
|
});
|
|
|
|
run_test('safe_full_names', () => {
|
|
const names = people.safe_full_names([me.user_id, isaac.user_id]);
|
|
assert.equal(names, 'Me Myself, Isaac Newton');
|
|
});
|
|
|
|
run_test('my_custom_profile_data', () => {
|
|
const person = people.get_by_email(me.email);
|
|
person.profile_data = {3: 'My address', 4: 'My phone number'};
|
|
assert.equal(people.my_custom_profile_data(3), 'My address');
|
|
assert.equal(people.my_custom_profile_data(4), 'My phone number');
|
|
});
|
|
|
|
run_test('bot_custom_profile_data', () => {
|
|
// If this test fails, then try opening organization settings > bots
|
|
// http://localhost:9991/#organization/bot-list-admin
|
|
// and then try to edit any of the bots.
|
|
const bot = {
|
|
email: '[email protected]',
|
|
user_id: 31,
|
|
full_name: 'Bot',
|
|
is_bot: true,
|
|
};
|
|
people.add(bot);
|
|
assert.equal(people.get_custom_profile_data(31, 3), null);
|
|
});
|
|
|
|
run_test('user_timezone', () => {
|
|
const expected_pref = {
|
|
timezone: 'US/Pacific',
|
|
format: 'H:mm',
|
|
};
|
|
|
|
global.page_params.twenty_four_hour_time = true;
|
|
assert.deepEqual(people.get_user_time_preferences(me.user_id), expected_pref);
|
|
|
|
expected_pref.format = 'h:mm A';
|
|
global.page_params.twenty_four_hour_time = false;
|
|
assert.deepEqual(people.get_user_time_preferences(me.user_id), expected_pref);
|
|
|
|
const actual_moment = zrequire('actual_moment', 'moment-timezone');
|
|
set_global('moment', function () { return actual_moment('20130208T080910'); });
|
|
|
|
global.page_params.twenty_four_hour_time = true;
|
|
assert.equal(people.get_user_time(me.user_id), '0:09');
|
|
|
|
expected_pref.format = 'h:mm A';
|
|
global.page_params.twenty_four_hour_time = false;
|
|
assert.equal(people.get_user_time(me.user_id), '12:09 AM');
|
|
});
|
|
|
|
run_test('user_type', () => {
|
|
const realm_admin = {
|
|
email: '[email protected]',
|
|
full_name: 'Realm Admin',
|
|
user_id: 32,
|
|
is_admin: true,
|
|
is_guest: false,
|
|
is_bot: false,
|
|
};
|
|
const guest = {
|
|
email: '[email protected]',
|
|
full_name: 'Guest User',
|
|
user_id: 33,
|
|
is_admin: false,
|
|
is_guest: true,
|
|
is_bot: false,
|
|
};
|
|
const bot = {
|
|
email: '[email protected]',
|
|
full_name: 'Example Bot',
|
|
user_id: 34,
|
|
is_admin: false,
|
|
is_guest: false,
|
|
is_bot: true,
|
|
};
|
|
|
|
people.add(realm_admin);
|
|
people.add(guest);
|
|
people.add(bot);
|
|
assert.equal(people.get_user_type(me.user_id), i18n.t('Member'));
|
|
assert.equal(people.get_user_type(realm_admin.user_id), i18n.t('Administrator'));
|
|
assert.equal(people.get_user_type(guest.user_id), i18n.t('Guest'));
|
|
assert.equal(people.get_user_type(bot.user_id), i18n.t('Bot'));
|
|
});
|
|
|
|
run_test('updates', () => {
|
|
const person = people.get_by_email('[email protected]');
|
|
people.set_full_name(person, 'Me the Third');
|
|
assert.equal(people.my_full_name(), 'Me the Third');
|
|
assert.equal(person.full_name, 'Me the Third');
|
|
assert.equal(people.get_user_id_from_name('Me the Third'), me.user_id);
|
|
});
|
|
|
|
run_test('get_by_user_id', () => {
|
|
let person = {
|
|
email: '[email protected]',
|
|
user_id: 42,
|
|
full_name: 'Mary',
|
|
};
|
|
people.add(person);
|
|
person = people.get_by_email('[email protected]');
|
|
assert.equal(person.full_name, 'Mary');
|
|
person = people.get_by_user_id(42);
|
|
assert.equal(person.email, '[email protected]');
|
|
|
|
people.set_full_name(person, 'Mary New');
|
|
person = people.get_by_user_id(42);
|
|
assert.equal(person.full_name, 'Mary New');
|
|
|
|
// deactivate() should eventually just take a user_id, but
|
|
// now it takes a full person object. Note that deactivate()
|
|
// won't actually make the user disappear completely.
|
|
people.deactivate(person);
|
|
person = people.get_active_user_for_email('[email protected]');
|
|
assert.equal(person, undefined);
|
|
person = people.get_by_user_id(42);
|
|
assert.equal(person.user_id, 42);
|
|
});
|
|
|
|
initialize();
|
|
|
|
run_test('set_custom_profile_field_data', () => {
|
|
const person = people.get_by_email(me.email);
|
|
me.profile_data = {};
|
|
const field = {id: 3, name: 'Custom long field', type: 'text', value: 'Field value', rendered_value: '<p>Field value</p>'};
|
|
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, '<p>Field value</p>');
|
|
});
|
|
|
|
initialize();
|
|
|
|
run_test('get_people_for_stream_create', () => {
|
|
const alice1 = {
|
|
email: '[email protected]',
|
|
user_id: 202,
|
|
full_name: 'Alice',
|
|
};
|
|
const alice2 = {
|
|
email: '[email protected]',
|
|
user_id: 203,
|
|
full_name: 'Alice',
|
|
};
|
|
const bob = {
|
|
email: '[email protected]',
|
|
user_id: 204,
|
|
full_name: 'Bob van Roberts',
|
|
};
|
|
people.add(alice1);
|
|
people.add(bob);
|
|
people.add(alice2);
|
|
assert.equal(people.get_active_human_count(), 4);
|
|
|
|
const others = people.get_people_for_stream_create();
|
|
const expected = [
|
|
{ email: '[email protected]', user_id: 202, full_name: 'Alice' },
|
|
{ email: '[email protected]', user_id: 203, full_name: 'Alice' },
|
|
{ email: '[email protected]', user_id: 204, 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: user_id}), 0);
|
|
people.incr_recipient_count(user_id);
|
|
people.incr_recipient_count(user_id);
|
|
assert.equal(people.get_recipient_count({user_id: user_id}), 2);
|
|
|
|
assert.equal(people.get_recipient_count({pm_recipient_count: 5}), 5);
|
|
});
|
|
|
|
run_test('filtered_users', () => {
|
|
const charles = {
|
|
email: '[email protected]',
|
|
user_id: 301,
|
|
full_name: 'Charles Dickens',
|
|
};
|
|
const maria = {
|
|
email: '[email protected]',
|
|
user_id: 302,
|
|
full_name: 'Maria Athens',
|
|
};
|
|
const ashton = {
|
|
email: '[email protected]',
|
|
user_id: 303,
|
|
full_name: 'Ashton Smith',
|
|
};
|
|
const linus = {
|
|
email: '[email protected]',
|
|
user_id: 304,
|
|
full_name: 'Linus Torvalds',
|
|
};
|
|
const noah = {
|
|
email: '[email protected]',
|
|
user_id: 305,
|
|
full_name: 'Nöôáàh Ëmerson',
|
|
};
|
|
const plain_noah = {
|
|
email: '[email protected]',
|
|
user_id: 306,
|
|
full_name: 'Nooaah Emerson',
|
|
};
|
|
|
|
people.add(charles);
|
|
people.add(maria);
|
|
people.add(ashton);
|
|
people.add(linus);
|
|
people.add(noah);
|
|
people.add(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
|
|
const foo = {
|
|
email: '[email protected]',
|
|
user_id: 42,
|
|
full_name: 'Foo Bar',
|
|
};
|
|
users.push(foo);
|
|
|
|
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', () => {
|
|
const emp401 = {
|
|
email: '[email protected]',
|
|
user_id: 401,
|
|
full_name: 'whatever 401',
|
|
};
|
|
const emp402 = {
|
|
email: '[email protected]',
|
|
user_id: 402,
|
|
full_name: 'whatever 402',
|
|
};
|
|
|
|
people.add(emp401);
|
|
people.add(emp402);
|
|
|
|
let emails_string = people.user_ids_string_to_emails_string('402,401');
|
|
assert.equal(emails_string, '[email protected],[email protected]');
|
|
|
|
emails_string = people.slug_to_emails('402,401-group');
|
|
assert.equal(emails_string, '[email protected],[email protected]');
|
|
|
|
emails_string = '[email protected],[email protected]';
|
|
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('[email protected]'), undefined);
|
|
});
|
|
|
|
initialize();
|
|
|
|
run_test('message_methods', () => {
|
|
const charles = {
|
|
email: '[email protected]',
|
|
user_id: 451,
|
|
full_name: 'Charles Dickens',
|
|
avatar_url: 'charles.com/foo.png',
|
|
is_guest: false,
|
|
};
|
|
// Maria is an intentionally incomplete user object without all attributes
|
|
const maria = {
|
|
email: '[email protected]',
|
|
user_id: 452,
|
|
full_name: 'Maria Athens',
|
|
};
|
|
people.add(charles);
|
|
people.add(maria);
|
|
|
|
assert.equal(people.small_avatar_url_for_person(maria),
|
|
'https://secure.gravatar.com/avatar/[email protected]?d=identicon&s=50');
|
|
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/451,452-group');
|
|
assert.equal(people.pm_perma_link(message), '#narrow/pm-with/30,451,452-group');
|
|
assert.equal(people.pm_reply_to(message),
|
|
'[email protected],[email protected]');
|
|
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/452-athens');
|
|
assert.equal(people.pm_perma_link(message), '#narrow/pm-with/30,452-pm');
|
|
assert.equal(people.pm_reply_to(message),
|
|
'[email protected]');
|
|
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/[email protected]?d=identicon&s=50'
|
|
);
|
|
|
|
blueslip.expect('error', 'Unknown user_id in get_by_user_id: 9999999');
|
|
message = {
|
|
avatar_url: undefined,
|
|
sender_email: '[email protected]',
|
|
sender_id: 9999999,
|
|
};
|
|
assert.equal(people.small_avatar_url(message),
|
|
'https://secure.gravatar.com/avatar/[email protected]?d=identicon&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 = {
|
|
email: '[email protected]',
|
|
user_id: 42,
|
|
full_name: 'Test Bot',
|
|
is_bot: true,
|
|
};
|
|
people.add(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
|
|
const polonius = {
|
|
email: '[email protected]',
|
|
user_id: 43,
|
|
full_name: 'Guest User',
|
|
is_bot: false,
|
|
is_guest: true,
|
|
};
|
|
people.add(polonius);
|
|
|
|
message = { sender_id: polonius.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', () => {
|
|
const unknown_user = {
|
|
email: '[email protected]',
|
|
user_id: 500,
|
|
unknown_local_echo_user: true,
|
|
};
|
|
|
|
const maria = {
|
|
email: '[email protected]',
|
|
user_id: 452,
|
|
full_name: 'Maria Athens',
|
|
};
|
|
|
|
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.report_late_add = function (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.report_late_add = function () {
|
|
throw 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 = {
|
|
email: '[email protected]',
|
|
user_id: 452,
|
|
full_name: 'Maria Athens',
|
|
};
|
|
const maria_recip = {
|
|
id: maria.user_id,
|
|
};
|
|
people.add(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: '[email protected]',
|
|
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', () => {
|
|
const person = {
|
|
email: '[email protected]',
|
|
user_id: 501,
|
|
full_name: 'Debra Henton',
|
|
};
|
|
people.add(person);
|
|
|
|
const slug = people.emails_to_slug(person.email);
|
|
assert.equal(slug, '501-debbie71');
|
|
|
|
const email = people.slug_to_emails(slug);
|
|
assert.equal(email, '[email protected]');
|
|
|
|
// Test undefined slug
|
|
assert.equal(people.emails_to_slug('[email protected]'), undefined);
|
|
});
|
|
|
|
initialize();
|
|
|
|
run_test('get_people_for_search_bar', () => {
|
|
message_store.user_ids = () => [];
|
|
|
|
for (const i of _.range(20)) {
|
|
const person = {
|
|
email: '[email protected]',
|
|
full_name: 'James Jones',
|
|
user_id: 1000 + i,
|
|
};
|
|
people.add(person);
|
|
}
|
|
|
|
const big_results = people.get_people_for_search_bar('James');
|
|
|
|
assert.equal(big_results.length, 20);
|
|
|
|
message_store.user_ids = () => {
|
|
return [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 = '[email protected]';
|
|
const new_email = '[email protected]';
|
|
const user_id = 502;
|
|
|
|
let person = {
|
|
email: old_email,
|
|
user_id: user_id,
|
|
full_name: 'Foo Barson',
|
|
};
|
|
people.add(person);
|
|
|
|
// Do sanity checks on our data.
|
|
assert.equal(people.get_by_email(old_email).user_id, user_id);
|
|
assert.equal(people.get_active_user_for_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.equal(people.get_active_user_for_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.filter(p => p.email === new_email)[0];
|
|
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: ' +
|
|
'[email protected] new email = [email protected]');
|
|
person = people.get_by_email(old_email);
|
|
assert.equal(person.user_id, user_id);
|
|
blueslip.reset();
|
|
});
|
|
|
|
initialize();
|
|
|
|
run_test('update_email_in_reply_to', () => {
|
|
const charles = {
|
|
email: '[email protected]',
|
|
user_id: 601,
|
|
full_name: 'Charles Dickens',
|
|
};
|
|
const maria = {
|
|
email: '[email protected]',
|
|
user_id: 602,
|
|
full_name: 'Maria Athens',
|
|
};
|
|
people.add(charles);
|
|
people.add(maria);
|
|
|
|
let reply_to = ' [email protected], [email protected]';
|
|
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, '[email protected]'),
|
|
'[email protected],[email protected]'
|
|
);
|
|
|
|
reply_to = ' [email protected], [email protected], [email protected]';
|
|
assert.equal(
|
|
people.update_email_in_reply_to(reply_to, 9999, 'whatever'),
|
|
reply_to
|
|
);
|
|
});
|
|
|
|
initialize();
|
|
|
|
run_test('track_duplicate_full_names', () => {
|
|
const stephen1 = {
|
|
email: '[email protected]',
|
|
user_id: 601,
|
|
full_name: 'Stephen King',
|
|
};
|
|
const stephen2 = {
|
|
email: '[email protected]',
|
|
user_id: 602,
|
|
full_name: 'Stephen King',
|
|
};
|
|
const maria = {
|
|
email: '[email protected]',
|
|
user_id: 603,
|
|
full_name: 'Maria Athens',
|
|
};
|
|
|
|
people.add(maria);
|
|
people.add(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(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'));
|
|
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'));
|
|
});
|
|
|
|
run_test('track_duplicate_full_names', () => {
|
|
const stephen1 = {
|
|
email: '[email protected]',
|
|
user_id: 601,
|
|
full_name: 'Stephen King',
|
|
};
|
|
const stephen2 = {
|
|
email: '[email protected]',
|
|
user_id: 602,
|
|
full_name: 'Stephen King',
|
|
};
|
|
const maria = {
|
|
email: '[email protected]',
|
|
user_id: 603,
|
|
full_name: 'Maria Athens',
|
|
};
|
|
people.add(stephen1);
|
|
people.add(stephen2);
|
|
people.add(maria);
|
|
|
|
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: '[email protected]',
|
|
user_id: 15,
|
|
full_name: 'Retiree',
|
|
},
|
|
];
|
|
|
|
params.realm_users = [
|
|
{
|
|
email: '[email protected]',
|
|
user_id: 16,
|
|
full_name: 'Alice',
|
|
},
|
|
];
|
|
params.cross_realm_bots = [
|
|
{
|
|
email: '[email protected]',
|
|
user_id: 17,
|
|
full_name: 'Test Bot',
|
|
},
|
|
];
|
|
|
|
const my_user_id = 42;
|
|
people.initialize(my_user_id, params);
|
|
|
|
assert.equal(people.get_active_user_for_email('[email protected]').full_name, 'Alice');
|
|
assert.equal(people.is_active_user_for_popover(17), true);
|
|
assert(people.is_cross_realm_email('[email protected]'));
|
|
assert(people.is_valid_email_for_compose('[email protected]'));
|
|
assert(people.is_valid_email_for_compose('[email protected]'));
|
|
assert(!people.is_valid_email_for_compose('[email protected]'));
|
|
assert(!people.is_valid_email_for_compose('[email protected]'));
|
|
assert(people.is_valid_bulk_emails_for_compose(['[email protected]', '[email protected]']));
|
|
assert(!people.is_valid_bulk_emails_for_compose(['[email protected]', '[email protected]']));
|
|
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(global.page_params.realm_users, undefined);
|
|
assert.equal(global.page_params.cross_realm_bots, undefined);
|
|
assert.equal(global.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: '[email protected]'}, 'fred'), false);
|
|
assert.equal(match({full_name: 'Fred Smith'}, 'fr'), true);
|
|
|
|
page_params.is_admin = true;
|
|
|
|
assert.equal(match({delivery_email: '[email protected]'}, 'fr'), true);
|
|
assert.equal(
|
|
match({delivery_email: 'bogus', email: '[email protected]'}, 'fr'),
|
|
false);
|
|
|
|
set_email_visibility(everyone);
|
|
page_params.is_admin = false;
|
|
assert.equal(match({delivery_email: '[email protected]'}, 'fr'), false);
|
|
assert.equal(match({email: '[email protected]'}, 'fr'), true);
|
|
|
|
// test normal stuff
|
|
assert.equal(match({email: '[email protected]'}, 'st'), false);
|
|
assert.equal(match({full_name: 'Fred Smith'}, 'st'), false);
|
|
assert.equal(match({full_name: 'Joe Frederick'}, 'st'), false);
|
|
|
|
assert.equal(match({email: '[email protected]'}, '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: '[email protected]'}, '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', function () {
|
|
const steven = {
|
|
email: '[email protected]',
|
|
user_id: 7,
|
|
full_name: 'Steven',
|
|
};
|
|
|
|
const maria = {
|
|
email: '[email protected]',
|
|
user_id: 728,
|
|
full_name: 'Maria',
|
|
};
|
|
|
|
people.add(steven);
|
|
people.add(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: [email protected]');
|
|
user_ids = people.emails_strings_to_user_ids_array('[email protected]');
|
|
assert.equal(user_ids, undefined);
|
|
blueslip.reset();
|
|
});
|