zulip/web/tests/activity.test.cjs

"use strict";

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

const {
    clear_buddy_list,
    override_user_matches_narrow_using_loaded_data,
    buddy_list_add_user_matching_view,
    buddy_list_add_other_user,
    stub_buddy_list_elements,
} = require("./lib/buddy_list.cjs");
const {make_realm} = require("./lib/example_realm.cjs");
const {make_stream} = require("./lib/example_stream.cjs");
const {make_user} = require("./lib/example_user.cjs");
const {make_message_list} = require("./lib/message_list.cjs");
const {mock_esm, set_global, zrequire} = require("./lib/namespace.cjs");
const {run_test, noop} = require("./lib/test.cjs");
const blueslip = require("./lib/zblueslip.cjs");
const $ = require("./lib/zjquery.cjs");

const _document = {
    hasFocus() {
        return true;
    },
};

const buddy_list_presence = mock_esm("../src/buddy_list_presence");
const keydown_util = mock_esm("../src/keydown_util", {handle() {}});
const padded_widget = mock_esm("../src/padded_widget");
const pm_list = mock_esm("../src/pm_list");
const popovers = mock_esm("../src/popovers");
const settings_data = mock_esm("../src/settings_data");
const sidebar_ui = mock_esm("../src/sidebar_ui");
const scroll_util = mock_esm("../src/scroll_util");
const background_task = mock_esm("../src/background_task");

set_global("document", _document);

const muted_users = zrequire("muted_users");
const presence = zrequire("presence");
const people = zrequire("people");
const buddy_data = zrequire("buddy_data");
const {buddy_list} = zrequire("buddy_list");
const activity = zrequire("activity");
const activity_ui = zrequire("activity_ui");
const stream_data = zrequire("stream_data");
const peer_data = zrequire("peer_data");
const message_lists = zrequire("message_lists");
const util = zrequire("util");
const {set_current_user, set_realm} = zrequire("state_data");
const {initialize_user_settings} = zrequire("user_settings");

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

const me = make_user({
    email: "me@zulip.com",
    user_id: 999,
    full_name: "Me Myself",
});

const alice = make_user({
    email: "alice@zulip.com",
    user_id: 1,
    full_name: "Alice Smith",
});
const fred = make_user({
    email: "fred@zulip.com",
    user_id: 2,
    full_name: "Fred Flintstone",
});
const jill = make_user({
    email: "jill@zulip.com",
    user_id: 3,
    full_name: "Jill Hill",
});
const mark = make_user({
    email: "mark@zulip.com",
    user_id: 4,
    full_name: "Marky Mark",
});
const norbert = make_user({
    email: "norbert@zulip.com",
    user_id: 5,
    full_name: "Norbert Oswald",
});

const zoe = make_user({
    email: "zoe@example.com",
    user_id: 6,
    full_name: "Zoe Yang",
});

people.add_active_user(alice, "server_events");
people.add_active_user(fred, "server_events");
people.add_active_user(jill, "server_events");
people.add_active_user(mark, "server_events");
people.add_active_user(norbert, "server_events");
people.add_active_user(zoe, "server_events");
people.add_active_user(me, "server_events");
people.initialize_current_user(me.user_id);

const $alice_stub = $.create("alice stub");
const $fred_stub = $.create("fred stub");

const rome_sub = make_stream({
    name: "Rome",
    subscribed: true,
    stream_id: 1001,
});
function add_sub_and_set_as_current_narrow(sub) {
    stream_data.add_sub_for_tests(sub);
    const filter_terms = [{operator: "stream", operand: String(sub.stream_id)}];
    message_lists.set_current(make_message_list(filter_terms));
}

function test(label, f) {
    run_test(label, (helpers) => {
        helpers.override(user_settings, "presence_enabled", true);
        // Simulate a small window by having the
        // fill_screen_with_content render the entire
        // list in one pass.  We will do more refined
        // testing in the buddy_list node tests.
        helpers.override(buddy_list, "fill_screen_with_content", () => {
            buddy_list.render_more({
                chunk_size: 100,
            });
        });

        stub_buddy_list_elements();

        presence.presence_info.set(alice.user_id, {status: "active"});
        presence.presence_info.set(fred.user_id, {status: "active"});
        presence.presence_info.set(jill.user_id, {status: "active"});
        presence.presence_info.set(mark.user_id, {status: "idle"});
        presence.presence_info.set(norbert.user_id, {status: "active"});
        presence.presence_info.set(zoe.user_id, {status: "active"});
        presence.presence_info.set(me.user_id, {status: "active"});

        helpers.override(background_task, "run_async_function_without_await", noop);
        clear_buddy_list(buddy_list);
        muted_users.set_muted_users([]);

        activity.clear_for_testing();
        activity_ui.set_cursor_and_filter();

        f(helpers);

        presence.clear_internal_data();
    });
}

run_test("reload_defaults", () => {
    activity.clear_for_testing();
    activity_ui.clear_for_testing();
    blueslip.expect("warn", "get_filter_text() is called before initialization");
    assert.equal(activity_ui.get_filter_text(), "");
});

test("presence_list_full_update", ({override}) => {
    override(padded_widget, "update_padding", noop);
    let args = [];
    override(buddy_list, "items_to_html", (opts) => {
        args = opts;
        return "<presence-rows>";
    });

    $("input.user-list-filter").trigger("focus");

    const user_ids = activity_ui.build_user_sidebar();

    assert.deepEqual(user_ids, [
        me.user_id,
        alice.user_id,
        fred.user_id,
        jill.user_id,
        norbert.user_id,
        zoe.user_id,
        mark.user_id,
    ]);

    assert.equal(args.items.length, 7);
    assert.equal(args.items[0].user_id, me.user_id);
});

test("direct_message_update_dom_counts", () => {
    const $count = $.create("alice-unread-count");
    const pm_key = alice.user_id.toString();
    const $li = $.create("alice stub");
    buddy_list_add_user_matching_view(pm_key, $li);
    $li.set_find_results(".unread_count", $count);
    $count.set_parents_result("li", $li);

    const counts = new Map([[pm_key, 5]]);
    $li.addClass("user_sidebar_entry");

    activity_ui.update_dom_with_unread_counts({pm_count: counts});
    assert.equal($count.text(), "5");

    counts.set(pm_key, 0);

    activity_ui.update_dom_with_unread_counts({pm_count: counts});
    assert.equal($count.text(), "");
});

test("handlers", ({override, override_rewire}) => {
    let filter_key_handlers;

    override(keydown_util, "handle", (opts) => {
        filter_key_handlers = opts.handlers;
    });
    override(scroll_util, "scroll_element_into_container", noop);
    override(padded_widget, "update_padding", noop);
    override(popovers, "hide_all", noop);
    override(sidebar_ui, "hide_all", noop);

    // This is kind of weak coverage; we are mostly making sure that
    // keys and clicks got mapped to functions that don't crash.
    const $me_li = $.create("me stub");
    const $alice_li = $.create("alice stub");
    const $fred_li = $.create("fred stub");

    // Simulate a small window by having the
    // fill_screen_with_content render the entire
    // list in one pass.  We will do more refined
    // testing in the buddy_list node tests.
    override(buddy_list, "fill_screen_with_content", () => {
        buddy_list.render_more({
            chunk_size: 100,
        });
        buddy_list_add_user_matching_view(me.user_id, $me_li);
        buddy_list_add_user_matching_view(alice.user_id, $alice_li);
        buddy_list_add_user_matching_view(fred.user_id, $fred_li);
    });

    let narrowed;

    function narrow_by_user_id(user_id) {
        assert.equal(user_id, alice.user_id);
        narrowed = true;
    }

    function init() {
        $.clear_all_elements();
        stub_buddy_list_elements();

        buddy_list.start_scroll_handler = noop;
        override_rewire(util, "call_function_periodically", noop);
        override_rewire(activity, "send_presence_to_server", noop);
        activity_ui.initialize({narrow_by_user_id});

        buddy_list.populate({
            all_user_ids: [me.user_id, alice.user_id, fred.user_id],
        });
    }

    (function test_filter_keys() {
        init();
        activity_ui.user_cursor.go_to(alice.user_id);
        filter_key_handlers.ArrowDown();
        filter_key_handlers.ArrowUp();
    })();

    (function test_click_filter() {
        init();
        const e = {
            stopPropagation() {},
        };

        const handler = $("input.user-list-filter").get_on_handler("focus");
        handler(e);
    })();

    (function test_enter_key() {
        init();

        $("input.user-list-filter").val("al");
        narrowed = false;
        activity_ui.user_cursor.go_to(alice.user_id);
        filter_key_handlers.Enter();
        assert.ok(narrowed);

        // get line coverage for cleared case
        activity_ui.user_cursor.clear();
        filter_key_handlers.Enter();
    })();

    (function test_click_handler() {
        init();
        // We wire up the click handler in click_handlers.ts,
        // so this just tests the called function.
        narrowed = false;
        activity_ui.narrow_for_user({$li: $alice_li});
        assert.ok(narrowed);
    })();

    (function test_blur_filter() {
        init();
        const e = {};
        const handler = $("input.user-list-filter").get_on_handler("blur");
        handler(e);
    })();
});

test("first/prev/next", ({override, override_rewire}) => {
    override_rewire(
        buddy_data,
        "user_matches_narrow_using_loaded_data",
        override_user_matches_narrow_using_loaded_data,
    );
    override(padded_widget, "update_padding", noop);
    stub_buddy_list_elements();

    // empty list
    assert.equal(buddy_list.first_key(), undefined);
    blueslip.reset();
    blueslip.expect("error", "Couldn't find key in buddy list");
    assert.equal(buddy_list.prev_key(alice.user_id), undefined);
    blueslip.reset();
    blueslip.expect("error", "Couldn't find key in buddy list");
    assert.equal(buddy_list.next_key(alice.user_id), undefined);
    blueslip.reset();

    // one user matching the view
    clear_buddy_list(buddy_list);
    buddy_list_add_user_matching_view(alice.user_id, $alice_stub);
    buddy_list.populate({
        all_user_ids: [alice.user_id],
    });
    assert.equal(buddy_list.first_key(), alice.user_id);
    assert.equal(buddy_list.prev_key(alice.user_id), undefined);
    assert.equal(buddy_list.next_key(alice.user_id), undefined);

    // two users matching the view
    clear_buddy_list(buddy_list);
    buddy_list_add_user_matching_view(alice.user_id, $alice_stub);
    buddy_list_add_user_matching_view(fred.user_id, $fred_stub);
    buddy_list.populate({
        all_user_ids: [alice.user_id, fred.user_id],
    });
    assert.equal(buddy_list.first_key(), alice.user_id);
    assert.equal(buddy_list.prev_key(alice.user_id), undefined);
    assert.equal(buddy_list.prev_key(fred.user_id), alice.user_id);
    assert.equal(buddy_list.next_key(alice.user_id), fred.user_id);
    assert.equal(buddy_list.next_key(fred.user_id), undefined);

    // one other user
    clear_buddy_list(buddy_list);
    buddy_list_add_other_user(fred.user_id, $fred_stub);
    buddy_list.populate({
        all_user_ids: [fred.user_id],
    });
    assert.equal(buddy_list.first_key(), fred.user_id);
    assert.equal(buddy_list.prev_key(fred.user_id), undefined);
    assert.equal(buddy_list.next_key(fred.user_id), undefined);

    // two other users
    clear_buddy_list(buddy_list);
    buddy_list_add_other_user(alice.user_id, $alice_stub);
    buddy_list_add_other_user(fred.user_id, $fred_stub);
    buddy_list.populate({
        all_user_ids: [alice.user_id, fred.user_id],
    });
    assert.equal(buddy_list.first_key(), alice.user_id);
    assert.equal(buddy_list.prev_key(alice.user_id), undefined);
    assert.equal(buddy_list.prev_key(fred.user_id), alice.user_id);
    assert.equal(buddy_list.next_key(alice.user_id), fred.user_id);
    assert.equal(buddy_list.next_key(fred.user_id), undefined);

    // one user matching the view, and one other user
    clear_buddy_list(buddy_list);
    buddy_list_add_user_matching_view(alice.user_id, $alice_stub);
    buddy_list_add_other_user(alice.user_id, $fred_stub);
    buddy_list.populate({
        all_user_ids: [alice.user_id, fred.user_id],
    });
    assert.equal(buddy_list.first_key(), alice.user_id);
    assert.equal(buddy_list.prev_key(alice.user_id), undefined);
    assert.equal(buddy_list.prev_key(fred.user_id), alice.user_id);
    assert.equal(buddy_list.next_key(alice.user_id), fred.user_id);
    assert.equal(buddy_list.next_key(fred.user_id), undefined);
});

test("insert_one_user_into_empty_list", ({override}) => {
    override(buddy_list_presence, "update_indicators", noop);
    override(user_settings, "user_list_style", 2);

    override(padded_widget, "update_padding", noop);
    let num_calls = 0;
    override(buddy_list, "item_to_html", (data) => {
        assert.deepEqual(data.item, {
            href: "#narrow/dm/1-Alice-Smith",
            name: "Alice Smith",
            user_id: 1,
            is_current_user: false,
            num_unread: 0,
            profile_picture: "/avatar/1",
            user_circle_class: "user-circle-active",
            status_emoji_info: undefined,
            status_text: undefined,
            has_status_text: false,
            user_list_style: {
                COMPACT: false,
                WITH_STATUS: true,
                WITH_AVATAR: false,
            },
            should_add_guest_user_indicator: false,
        });
        num_calls = num_calls + 1;

        return "<presence-row>";
    });

    add_sub_and_set_as_current_narrow(rome_sub);

    buddy_list_add_user_matching_view(alice.user_id, $alice_stub);
    peer_data.set_subscribers(rome_sub.stream_id, [alice.user_id]);
    activity_ui.redraw_user(alice.user_id);
    assert.equal(num_calls, 1);

    clear_buddy_list(buddy_list);
    buddy_list_add_other_user(alice.user_id, $alice_stub);
    peer_data.set_subscribers(rome_sub.stream_id, []);
    activity_ui.redraw_user(alice.user_id);
    assert.equal(num_calls, 2);
});

test("insert_alice_then_fred", ({override}) => {
    let other_users_appended;
    override(buddy_list.$other_users_list[0], "append", (element) => {
        other_users_appended = element;
    });
    override(padded_widget, "update_padding", noop);
    override(buddy_list_presence, "update_indicators", noop);

    activity_ui.redraw_user(alice.user_id);
    assert.ok(other_users_appended.innerHTML.includes('data-user-id="1"'));
    assert.ok(other_users_appended.innerHTML.includes("user-circle-active"));

    activity_ui.redraw_user(fred.user_id);
    assert.ok(other_users_appended.innerHTML.includes('data-user-id="2"'));
    assert.ok(other_users_appended.innerHTML.includes("user-circle-active"));
});

test("insert_fred_then_alice_then_rename, both as users matching view", ({override}) => {
    add_sub_and_set_as_current_narrow(rome_sub);
    peer_data.set_subscribers(rome_sub.stream_id, [alice.user_id, fred.user_id]);

    let users_matching_view_appended;
    override(buddy_list.$users_matching_view_list[0], "append", (element) => {
        users_matching_view_appended = element;
    });
    override(padded_widget, "update_padding", noop);
    override(buddy_list_presence, "update_indicators", noop);
    buddy_list_add_user_matching_view(alice.user_id, $alice_stub);
    buddy_list_add_user_matching_view(fred.user_id, $fred_stub);

    activity_ui.redraw_user(fred.user_id);
    assert.ok(users_matching_view_appended.innerHTML.includes('data-user-id="2"'));
    assert.ok(users_matching_view_appended.innerHTML.includes("user-circle-active"));

    let inserted;
    $fred_stub[0].before = (element) => {
        inserted = element;
    };

    let fred_removed;
    $fred_stub[0].remove = () => {
        fred_removed = true;
    };

    activity_ui.redraw_user(alice.user_id);
    assert.ok(inserted.innerHTML.includes('data-user-id="1"'));
    assert.ok(inserted.innerHTML.includes("user-circle-active"));

    // Next rename fred to Aaron.
    const fred_with_new_name = {
        email: fred.email,
        user_id: fred.user_id,
        full_name: "Aaron",
    };
    people.add_active_user(fred_with_new_name);

    $alice_stub[0].before = (element) => {
        inserted = element;
    };

    activity_ui.redraw_user(fred_with_new_name.user_id);
    assert.ok(fred_removed);
    assert.ok(users_matching_view_appended.innerHTML.includes('data-user-id="2"'));

    // restore old Fred data
    people.add_active_user(fred);
});

test("insert_fred_then_alice_then_rename, both as other users", ({override}) => {
    add_sub_and_set_as_current_narrow(rome_sub);
    peer_data.set_subscribers(rome_sub.stream_id, []);

    let other_users_appended;
    override(buddy_list.$other_users_list[0], "append", (element) => {
        other_users_appended = element;
    });
    override(padded_widget, "update_padding", noop);
    override(buddy_list_presence, "update_indicators", noop);

    buddy_list_add_other_user(alice.user_id, $alice_stub);
    buddy_list_add_other_user(fred.user_id, $fred_stub);

    activity_ui.redraw_user(fred.user_id);
    assert.ok(other_users_appended.innerHTML.includes('data-user-id="2"'));
    assert.ok(other_users_appended.innerHTML.includes("user-circle-active"));

    let inserted;
    $fred_stub[0].before = (element) => {
        inserted = element;
    };

    let fred_removed;
    $fred_stub[0].remove = () => {
        fred_removed = true;
    };

    activity_ui.redraw_user(alice.user_id);
    assert.ok(inserted.innerHTML.includes('data-user-id="1"'));
    assert.ok(inserted.innerHTML.includes("user-circle-active"));

    // Next rename fred to Aaron.
    const fred_with_new_name = {
        email: fred.email,
        user_id: fred.user_id,
        full_name: "Aaron",
    };
    people.add_active_user(fred_with_new_name);

    $alice_stub[0].before = (element) => {
        inserted = element;
    };

    activity_ui.redraw_user(fred_with_new_name.user_id);
    assert.ok(fred_removed);
    assert.ok(other_users_appended.innerHTML.includes('data-user-id="2"'));

    // restore old Fred data
    people.add_active_user(fred);
});

test("insert_unfiltered_user_with_filter", () => {
    // This test only tests that we do not explode when
    // try to insert Fred into a list where he does not
    // match the search filter.
    const $user_filter = $("input.user-list-filter");
    $user_filter.val("do-not-match-filter");
    activity_ui.redraw_user(fred.user_id);
});

test("realm_presence_disabled", ({override}) => {
    override(realm, "realm_presence_disabled", true);

    activity_ui.redraw_user();
    activity_ui.build_user_sidebar();
});

test("redraw_muted_user", () => {
    muted_users.add_muted_user(mark.user_id);
    activity_ui.redraw_user(mark.user_id);
});

test("update_presence_info", ({override}) => {
    override(pm_list, "update_private_messages", noop);
    override(buddy_list_presence, "update_indicators", noop);

    override(realm, "realm_presence_disabled", false);
    override(realm, "server_presence_ping_interval_seconds", 60);
    override(realm, "server_presence_offline_threshold_seconds", 200);

    let info = {
        [me.user_id]: {
            active_timestamp: 500,
            idle_timestamp: 500,
        },
    };

    const $alice_li = $.create("alice stub");
    buddy_list_add_user_matching_view(alice.user_id, $alice_li);

    let inserted;
    override(buddy_list, "insert_or_move", () => {
        inserted = true;
    });

    presence.presence_info.delete(me.user_id);
    activity_ui.update_presence_info(info);
    assert.ok(inserted);
    assert.deepEqual(presence.presence_info.get(me.user_id).status, "active");

    info = {
        [alice.user_id]: {
            active_timestamp: 500,
            idle_timestamp: 500,
        },
    };

    presence.presence_info.delete(alice.user_id);
    activity_ui.update_presence_info(info);
    assert.ok(inserted);

    const expected = {status: "active", last_active: 500};
    assert.deepEqual(presence.presence_info.get(alice.user_id), expected);

    // Test invalid and inaccessible user IDs.
    const invalid_user_id = 99;
    info = {
        [invalid_user_id]: {
            active_timestamp: 500,
            idle_timestamp: 500,
        },
    };
    activity_ui.update_presence_info(info);
    assert.equal(presence.presence_info.get(invalid_user_id), undefined);

    const inaccessible_user_id = 10;
    settings_data.user_can_access_all_other_users = () => false;
    const inaccessible_user = people.make_user(
        inaccessible_user_id,
        "user10@zulipdev.com",
        "Unknown user",
    );
    people._add_user(inaccessible_user);
    info = {
        [inaccessible_user_id]: {
            active_timestamp: 500,
            idle_timestamp: 500,
        },
    };
    activity_ui.update_presence_info(info);
    assert.equal(presence.presence_info.get(inaccessible_user_id), undefined);
});

test("check_should_redraw_new_user", ({override}) => {
    presence.presence_info.set(9999, {status: "active"});

    // A user that wasn't yet known, but has presence info should be redrawn
    // when being added.
    assert.equal(activity_ui.check_should_redraw_new_user(9999), true);

    // We don't even build the user sidebar if realm_presence_disabled is true,
    // so nothing to redraw.
    override(realm, "realm_presence_disabled", true);
    assert.equal(activity_ui.check_should_redraw_new_user(9999), false);

    override(realm, "realm_presence_disabled", false);
    // A new user that didn't have presence info should not be redrawn.
    assert.equal(activity_ui.check_should_redraw_new_user(99999), false);
});