Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

45.2 KB
Raw Blame
"use strict";

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

const {mock_esm, mock_jquery, zrequire} = require("./lib/namespace.cjs");
const {run_test, noop} = require("./lib/test.cjs");
const blueslip = require("./lib/zblueslip.cjs");
const {$} = require("./lib/zjquery.cjs");

// We need these stubs to get by instanceof checks.
// The ListWidget library allows you to insert objects
// that are either jQuery, Element, or just raw HTML
// strings.  We initially test with raw strings.
const scroll_util = mock_esm("../src/scroll_util");

// We only need very simple jQuery wrappers for when the

// "real" code wraps html or sets up click handlers.
// We'll simulate most other objects ourselves.
mock_jquery((arg) => {
    if (arg.to_jquery) {
        return arg.to_jquery();
    }

    return {
        addClass() {
            return this;
        },
        _replace(regex, string) {
            arg = arg.replace(regex, () => string);
        },
        html: () => arg,
    };
});

const ListWidget = zrequire("list_widget");

const {INITIAL_RENDER_COUNT, LOAD_COUNT} = ListWidget.DEFAULTS;

// We build objects here that simulate jQuery containers.
// The main thing to do at first is simulate that our
// scroll container is the nearest ancestor to our main
// container that has a max-height attribute, and then
// the scroll container will have a scroll event attached to
// it.  This is a good time to read set_up_event_handlers
// in the real code.

function make_container() {
    const $container = {attr: noop, empty: noop, data: noop};

    // Make our append function just set a field we can
    // check in our tests.
    $container.append = ($data) => {
        $container.$appended_data = $data;
    };

    return $container;
}

function make_scroll_container() {
    const $scroll_container = {[0]: {}, cleared: false};

    // Capture the scroll callback so we can call it in
    // our tests.
    $scroll_container.on = (ev, f) => {
        assert.equal(ev, "scroll.list_widget_container");
        $scroll_container.call_scroll = () => {
            f.call($scroll_container[0]);
        };
    };

    $scroll_container.off = (ev) => {
        assert.equal(ev, "scroll.list_widget_container");
        $scroll_container.cleared = true;
    };
    $scroll_container.is = () => false;

    return $scroll_container;
}

function make_sort_container() {
    const $sort_container = {cleared: false, siblings_deactivated: false};

    $sort_container.find = (selector) => {
        assert.equal(selector, "[data-sort].active");
        return {
            not($excluded) {
                assert.ok($excluded !== undefined);
                return {
                    removeClass(cls) {
                        assert.equal(cls, "active");
                        $sort_container.siblings_deactivated = true;
                    },
                };
            },
        };
    };

    $sort_container.on = (ev, sel, f) => {
        assert.equal(ev, "click.list_widget_sort");
        assert.equal(sel, "[data-sort]");
        $sort_container.f = f;
    };

    $sort_container.off = (ev) => {
        assert.equal(ev, "click.list_widget_sort");
        $sort_container.cleared = true;
    };

    return $sort_container;
}

function make_filter_element() {
    const $element = {cleared: false, clear_button_elem_cleared: false};

    $element.on = (ev, f) => {
        assert.equal(ev, "input.list_widget_filter");
        $element.f = f;
    };

    $element.off = (ev) => {
        assert.equal(ev, "input.list_widget_filter");
        $element.cleared = true;
    };

    const clear_input_element = {};

    clear_input_element.on = (ev, f) => {
        assert.equal(ev, "click");
        clear_input_element.f = f;
    };

    clear_input_element.off = (ev) => {
        assert.equal(ev, "click");
        $element.clear_button_elem_cleared = true;
    };

    $element.siblings = (selector) => {
        assert.equal(selector, ".clear-filter");
        return clear_input_element;
    };

    return $element;
}

function make_search_input() {
    const $element = {};

    // Allow ourselves to be wrapped by $(...) and
    // return ourselves.
    /* istanbul ignore next */
    $element.to_jquery = () => $element;

    $element.on = (event_name, f) => {
        assert.equal(event_name, "input.list_widget_filter");
        $element.simulate_input_event = () => {
            const elem = {
                value: $element.val(),
            };
            f.call(elem);
        };
    };

    const clear_search_button_element = {
        on(event, f) {
            assert.equal(event, "click");
            $element.simulate_clear_search = () => {
                f.call();
            };
        },
    };

    $element.siblings = (selector) => {
        assert.equal(selector, ".clear-filter");
        return clear_search_button_element;
    };

    return $element;
}

function div(item) {
    return "<div>" + item + "</div>";
}

function make_items(count) {
    return Array.from({length: count}, (_, i) => ({value: i + 1, key: i + 1}));
}

// Adds items with the given sort keys to the widget's list, as a caller
// does before inserting their rows.
function add_items(widget, list, keys) {
    const items = keys.map((key, i) => ({value: list.length + i + 1, key}));
    list.push(...items);
    widget.replace_list_data(list, false);
    widget.filter_and_sort();
    return items;
}

// A widget over `list` with a stand-in for its DOM: `rows` holds the items
// that have a row, in DOM order, and refuses to render an item twice; the
// row stubs remove, replace and position rows the way jQuery does. `stats`
// counts the redraws that threw rendered rows away and lists the items
// whose row was replaced in place.
function make_tracked_widget(list, opts = {}) {
    const rows = [];
    const stats = {redraws: 0, replaced: []};
    function items_in(html) {
        return html
            .matchAll(/data-item=(\d+)/g)
            .map((match) => list[Number(match[1]) - 1])
            .toArray();
    }
    function insert_items(index, $data) {
        for (const [i, item] of items_in($data.html()).entries()) {
            assert.ok(!rows.includes(item), `item ${item.value} was rendered twice`);
            rows.splice(index + i, 0, item);
        }
    }
    function row(item) {
        return {
            item,
            get length() {
                return rows.includes(item) ? 1 : 0;
            },
            remove() {
                assert.ok(rows.includes(item), "row is not in the DOM");
                rows.splice(rows.indexOf(item), 1);
            },
            after($data) {
                assert.ok(rows.includes(item), "row is not in the DOM");
                insert_items(rows.indexOf(item) + 1, $data);
            },
            replaceWith($data) {
                assert.deepEqual(items_in($data.html()), [item]);
                stats.replaced.push(item);
            },
            prev() {
                // For the first row, row(undefined) stands in for no row.
                return row(rows[rows.indexOf(item) - 1]);
            },
            is($other) {
                return $other.item === item;
            },
        };
    }
    const $container = make_container();
    $container.append = ($data) => {
        insert_items(rows.length, $data);
    };
    $container.prepend = ($data) => {
        insert_items(0, $data);
    };
    $container.empty = () => {
        if (rows.length > 0) {
            stats.redraws += 1;
        }
        rows.length = 0;
    };
    const $scroll_container = make_scroll_container();
    $scroll_container.find = ($row) => $row;
    const widget = ListWidget.create($container, list, {
        name: "tracked",
        modifier_html: (item) => `<tr data-item=${item.value}></tr>\n`,
        get_item: (item) => item,
        html_selector: row,
        $simplebar_container: $scroll_container,
        ...opts,
    });
    return {widget, rows, row, stats};
}

run_test("scrolling", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();

    const items = [];

    let get_scroll_element_called = false;
    scroll_util.get_scroll_element = ($element) => {
        get_scroll_element_called = true;
        return $element;
    };

    for (let i = 0; i < 200; i += 1) {
        items.push("item " + i);
    }

    const opts = {
        modifier_html: (item) => item,
        get_item: (item) => item,
        $simplebar_container: $scroll_container,
    };

    ListWidget.create($container, items, opts);

    assert.deepEqual(
        $container.$appended_data.html(),
        items.slice(0, INITIAL_RENDER_COUNT).join(""),
    );
    assert.equal(get_scroll_element_called, true);

    // Set up our fake geometry so it forces a scroll action.
    $scroll_container[0].scrollTop = 180;
    $scroll_container[0].clientHeight = 100;
    $scroll_container[0].scrollHeight = 260;

    // Scrolling gets the next two elements from the list into
    // our widget.
    $scroll_container.call_scroll();
    assert.deepEqual(
        $container.$appended_data.html(),
        items.slice(INITIAL_RENDER_COUNT, INITIAL_RENDER_COUNT + LOAD_COUNT).join(""),
    );
});

run_test("not_scrolling", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();

    const items = [];

    let get_scroll_element_called = false;
    scroll_util.get_scroll_element = ($element) => {
        get_scroll_element_called = true;
        return $element;
    };

    let post_scroll__pre_render_callback_called = false;
    const post_scroll__pre_render_callback = () => {
        post_scroll__pre_render_callback_called = true;
    };

    let get_min_load_count_called = false;
    const get_min_load_count = (_offset, load_count) => {
        get_min_load_count_called = true;
        return load_count;
    };

    for (let i = 0; i < 200; i += 1) {
        items.push("item " + i);
    }

    const opts = {
        modifier_html: (item) => item,
        get_item: (item) => item,
        $simplebar_container: $scroll_container,
        is_scroll_position_for_render: () => false,
        post_scroll__pre_render_callback,
        get_min_load_count,
    };

    ListWidget.create($container, items, opts);

    assert.deepEqual(
        $container.$appended_data.html(),
        items.slice(0, INITIAL_RENDER_COUNT).join(""),
    );
    assert.equal(get_scroll_element_called, true);

    // Set up our fake geometry.
    $scroll_container[0].scrollTop = 180;
    $scroll_container[0].clientHeight = 100;
    $scroll_container[0].scrollHeight = 260;

    // Since `should_render` is always false, no elements will be
    // added regardless of scrolling.
    $scroll_container.call_scroll();
    // $appended_data remains the same.
    assert.deepEqual(
        $container.$appended_data.html(),
        items.slice(0, INITIAL_RENDER_COUNT).join(""),
    );
    assert.equal(post_scroll__pre_render_callback_called, true);
    assert.equal(get_min_load_count_called, true);
});

run_test("filtering", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();

    const $search_input = make_search_input();

    let last_filter_value = "";
    const list = ["apple", "banana", "carrot", "dog", "egg", "fence", "grape"];
    const opts = {
        filter: {
            $element: $search_input,
            predicate: (item, value) => item.includes(value),
        },
        modifier_html(item, filter_value) {
            last_filter_value = filter_value;
            return div(item);
        },
        get_item: (item) => item,
        $simplebar_container: $scroll_container,
    };

    const widget = ListWidget.create($container, list, opts);

    let expected_html =
        "<div>apple</div>" +
        "<div>banana</div>" +
        "<div>carrot</div>" +
        "<div>dog</div>" +
        "<div>egg</div>" +
        "<div>fence</div>" +
        "<div>grape</div>";

    assert.deepEqual($container.$appended_data.html(), expected_html);

    // Filtering will pick out dog/egg/grape when we put "g"
    // into our search input.  (This uses the default filter, which
    // is a glorified indexOf call.)
    $search_input.val = () => "g";
    $search_input.simulate_input_event();
    assert.equal(last_filter_value, "g");
    assert.deepEqual(widget.get_current_list(), ["dog", "egg", "grape"]);
    expected_html = "<div>dog</div><div>egg</div><div>grape</div>";
    assert.deepEqual($container.$appended_data.html(), expected_html);

    $search_input.simulate_clear_search();
    assert.deepEqual(widget.get_current_list(), list);

    // Reset the search input value to test that list is updated correctly.
    $search_input.val = () => "g";
    $search_input.simulate_input_event();

    // We can insert new data into the widget.
    const new_data = ["greta", "faye", "gary", "frank", "giraffe", "fox"];

    widget.replace_list_data(new_data);
    expected_html = "<div>greta</div><div>gary</div><div>giraffe</div>";
    assert.deepEqual($container.$appended_data.html(), expected_html);
});

run_test("no filtering", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();

    let callback_called = false;
    // Opts does not require a filter key.
    const opts = {
        modifier_html: (item) => div(item),
        $simplebar_container: $scroll_container,
        callback_after_render() {
            callback_called = true;
        },
        get_item: (item) => item,
    };
    const widget = ListWidget.create($container, ["apple", "banana"], opts);
    widget.render();
    assert.deepEqual(callback_called, true);

    const expected_html = "<div>apple</div><div>banana</div>";
    assert.deepEqual($container.$appended_data.html(), expected_html);
});

function sort_button(opts) {
    // The complications here are due to needing to find
    // the list via complicated HTML assumptions. Also, we
    // don't have any abstraction for the button and its
    // siblings other than direct jQuery actions.

    function attr(name) {
        switch (name) {
            case "data-sort":
                return opts.sort_type;
            case "data-sort-prop":
                return opts.prop_name;
            /* istanbul ignore next */
            default:
                throw new Error("unknown attribute: " + name);
        }
    }

    function lookup(sel, value) {
        return (selector) => {
            assert.equal(sel, selector);
            return value;
        };
    }

    const classList = new Set();

    const $button = {
        attr,
        closest: lookup(".progressive-table-wrapper", {
            data: lookup("list-widget", opts.list_name),
        }),
        addClass(cls) {
            classList.add(cls);
        },
        hasClass: (cls) => classList.has(cls),
        removeClass(cls) {
            classList.delete(cls);
        },
        siblings: lookup(".active", {
            removeClass(cls) {
                assert.equal(cls, "active");
                $button.siblings_deactivated = true;
            },
        }),
        siblings_deactivated: false,
        to_jquery: () => $button,
    };

    return $button;
}

run_test("wire up filter element", () => {
    const lst = ["alice", "JESSE", "moses", "scott", "Sean", "Xavier"];

    const $container = make_container();
    const $scroll_container = make_scroll_container();
    const $filter_element = make_filter_element();

    const opts = {
        filter: {
            filterer: (list, value) => list.filter((item) => item.toLowerCase().includes(value)),
            $element: $filter_element,
        },
        modifier_html: (s) => "(" + s + ")",
        get_item: (item) => item,
        $simplebar_container: $scroll_container,
    };

    ListWidget.create($container, lst, opts);
    $filter_element.f.apply({value: "se"});
    assert.equal($container.$appended_data.html(), "(JESSE)(moses)(Sean)");
});

run_test("sorting", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    const $sort_container = make_sort_container();

    let cleared;
    $container.empty = () => {
        cleared = true;
    };

    const alice = {name: "alice", salary: 50};
    const bob = {name: "Bob", salary: 40};
    const cal = {name: "cal", salary: 30};
    const dave = {name: "dave", salary: 25};
    const ellen = {name: "ellen", salary: 95};

    const list = [bob, ellen, dave, alice, cal];

    const opts = {
        name: "sorting-list",
        $parent_container: $sort_container,
        modifier_html: (item) => div(item.name) + div(item.salary),
        get_item: (item) => item,
        filter: {
            predicate: () => true,
        },
        sort_fields: {
            ...ListWidget.generic_sort_functions("alphabetic", ["name"]),
            ...ListWidget.generic_sort_functions("numeric", ["salary"]),
        },
        $simplebar_container: $scroll_container,
    };

    function html_for(people) {
        return people.map((item) => opts.modifier_html(item)).join("");
    }

    ListWidget.create($container, list, opts);

    let button_opts;
    let $button;
    let expected_html;

    button_opts = {
        sort_type: "alphabetic",
        prop_name: "name",
        list_name: "my-list",
        active: false,
    };

    $button = sort_button(button_opts);

    $sort_container.f.apply($button);

    assert.ok(cleared);
    assert.ok($sort_container.siblings_deactivated);

    expected_html = html_for([alice, bob, cal, dave, ellen]);
    assert.deepEqual($container.$appended_data.html(), expected_html);

    // Hit same button again to reverse the data.
    cleared = false;
    $sort_container.f.apply($button);
    assert.ok(cleared);
    expected_html = html_for([ellen, dave, cal, bob, alice]);
    assert.deepEqual($container.$appended_data.html(), expected_html);
    assert.ok($button.hasClass("descend"));

    // And then hit a third time to go back to the forward sort.
    cleared = false;
    $sort_container.f.apply($button);
    assert.ok(cleared);
    expected_html = html_for([alice, bob, cal, dave, ellen]);
    assert.deepEqual($container.$appended_data.html(), expected_html);
    assert.ok(!$button.hasClass("descend"));

    // Now try a numeric sort.
    button_opts = {
        sort_type: "numeric",
        prop_name: "salary",
        list_name: "my-list",
        active: false,
    };

    $button = sort_button(button_opts);

    cleared = false;
    $sort_container.siblings_deactivated = false;

    $sort_container.f.apply($button);

    assert.ok(cleared);
    assert.ok($sort_container.siblings_deactivated);

    expected_html = html_for([dave, cal, bob, alice, ellen]);
    assert.deepEqual($container.$appended_data.html(), expected_html);

    // Hit same button again to reverse the numeric sort.
    cleared = false;
    $sort_container.f.apply($button);
    assert.ok(cleared);
    expected_html = html_for([ellen, alice, bob, cal, dave]);
    assert.deepEqual($container.$appended_data.html(), expected_html);
});

run_test("Apply consecutive sorts", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    const $sort_container = make_sort_container();

    let cleared;
    $container.empty = () => {
        cleared = true;
    };

    const alice = {name: "alice", salary: 50};
    const bob = {name: "bob", salary: 40};
    const cal = {name: "cal", salary: 30};
    const dave = {name: "dave", salary: 20};
    const ellen = {name: "ellen", salary: 95};
    const bob_2 = {name: "bob", salary: 20};
    const cal_2 = {name: "cal", salary: 60};

    const list = [alice, bob, cal, dave, ellen, bob_2, cal_2];

    const opts = {
        name: "sorting-list",
        $parent_container: $sort_container,
        modifier_html: (item) => div(item.name) + div(item.salary),
        get_item: (item) => item,
        filter: {
            predicate: () => true,
        },
        sort_fields: {
            ...ListWidget.generic_sort_functions("alphabetic", ["name"]),
            ...ListWidget.generic_sort_functions("numeric", ["salary"]),
        },
        $simplebar_container: $scroll_container,
    };

    function html_for(people) {
        return people.map((item) => opts.modifier_html(item)).join("");
    }

    ListWidget.create($container, list, opts);

    let button_opts;
    let $button;
    let expected_html;

    // Apply sorting by salary first, then by name
    button_opts = {
        sort_type: "numeric",
        prop_name: "salary",
        list_name: "my-list",
        active: false,
    };

    $button = sort_button(button_opts);

    $sort_container.f.apply($button);

    button_opts = {
        sort_type: "alphabetic",
        prop_name: "name",
        list_name: "my-list",
        active: false,
    };

    $button = sort_button(button_opts);

    $sort_container.f.apply($button);

    assert.ok(cleared);
    assert.ok($sort_container.siblings_deactivated);

    expected_html = html_for([alice, bob_2, bob, cal, cal_2, dave, ellen]);
    assert.deepEqual($container.$appended_data.html(), expected_html);

    // Apply sorting by salary again, the previous sort by salary should be removed
    button_opts = {
        sort_type: "numeric",
        prop_name: "salary",
        list_name: "my-list",
        active: false,
    };

    $button = sort_button(button_opts);

    cleared = false;
    $sort_container.f.apply($button);
    assert.ok(cleared);
    expected_html = html_for([bob_2, dave, cal, bob, alice, cal_2, ellen]);
    assert.deepEqual($container.$appended_data.html(), expected_html);
    assert.ok(!$button.hasClass("descend"));

    // Hit the salary field again to reverse the salary sorting
    cleared = false;
    $sort_container.f.apply($button);
    assert.ok(cleared);
    expected_html = html_for([ellen, cal_2, alice, bob, cal, bob_2, dave]);
    assert.deepEqual($container.$appended_data.html(), expected_html);
    assert.ok($button.hasClass("descend"));
});

run_test("custom sort", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();

    const n42 = {x: 6, y: 7};
    const n43 = {x: 1, y: 43};
    const n44 = {x: 4, y: 11};

    const list = [n42, n43, n44];

    function sort_by_x(a, b) {
        return a.x - b.x;
    }

    function sort_by_product(a, b) {
        return a.x * a.y - b.x * b.y;
    }

    const widget = ListWidget.create($container, list, {
        name: "custom-sort-list",
        modifier_html: (n) => "(" + n.x + ", " + n.y + ")",
        get_item: (item) => item,
        sort_fields: {
            product: sort_by_product,
            x_value: sort_by_x,
        },
        init_sort: sort_by_product,
        $simplebar_container: $scroll_container,
    });

    assert.deepEqual($container.$appended_data.html(), "(6, 7)(1, 43)(4, 11)");

    widget.sort("x_value");
    assert.deepEqual($container.$appended_data.html(), "(1, 43)(4, 11)(6, 7)");

    // We can sort without registering the function, too.
    function sort_by_y(a, b) {
        return a.y - b.y;
    }

    widget.sort(sort_by_y);
    assert.deepEqual($container.$appended_data.html(), "(6, 7)(4, 11)(1, 43)");
});

run_test("handle_sort without parent_container", () => {
    // When handle_sort is called without $parent_container, it falls back
    // to using $th.siblings(".active") to deactivate other sort headers.
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    $container.empty = noop;

    const widget = ListWidget.create($container, [{name: "bob"}, {name: "alice"}], {
        name: "fallback-sort-test",
        modifier_html: (item) => div(item.name),
        get_item: (item) => item,
        sort_fields: {
            ...ListWidget.generic_sort_functions("alphabetic", ["name"]),
        },
        $simplebar_container: $scroll_container,
    });

    const $button = sort_button({
        sort_type: "alphabetic",
        prop_name: "name",
        list_name: "fallback-sort-test",
        active: false,
    });

    ListWidget.handle_sort($button, widget);
    assert.ok($button.siblings_deactivated);
    assert.deepEqual($container.$appended_data.html(), "<div>alice</div><div>bob</div>");
});

run_test("clear_event_handlers", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    const $sort_container = make_sort_container();
    const $filter_element = make_filter_element();

    // We don't care about actual data for this test.
    const list = [];

    const opts = {
        name: "list-we-create-twice",
        $parent_container: $sort_container,
        modifier_html() {},
        get_item() {},
        filter: {
            $element: $filter_element,
            predicate: /* istanbul ignore next */ () => true,
        },
        $simplebar_container: $scroll_container,
    };

    // Create it the first time.
    ListWidget.create($container, list, opts);
    assert.equal($sort_container.cleared, false);
    assert.equal($scroll_container.cleared, false);
    assert.equal($filter_element.cleared, false);
    assert.equal($filter_element.clear_button_elem_cleared, false);

    // The second time we'll clear the old events.
    ListWidget.create($container, list, opts);
    assert.equal($sort_container.cleared, true);
    assert.equal($scroll_container.cleared, true);
    assert.equal($filter_element.cleared, true);
    assert.equal($filter_element.clear_button_elem_cleared, true);
});

run_test("sort helpers", () => {
    /*
        We mostly test our sorting helpers using the
        actual widget, but this test gets us a bit
        more line coverage.
    */
    const alice2 = {name: "alice", id: 2};
    const alice10 = {name: "alice", id: 10};
    const bob2 = {name: "bob", id: 2};
    const bob10 = {name: "bob", id: 10};

    const alpha_cmp = ListWidget.alphabetic_sort("name");
    const num_cmp = ListWidget.numeric_sort("id");

    assert.equal(alpha_cmp(alice2, alice10), 0);
    assert.equal(alpha_cmp(alice2, bob2), -1);
    assert.equal(alpha_cmp(bob2, alice10), 1);
    assert.equal(num_cmp(alice2, bob2), 0);
    assert.equal(num_cmp(alice2, bob10), -1);
    assert.equal(num_cmp(alice10, bob2), 1);
});

run_test("replace_list_data w/filter update", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();

    const list = [1, 2, 3, 4];
    let num_updates = 0;

    const widget = ListWidget.create($container, list, {
        name: "replace-list",
        modifier_html: (n) => "(" + n.toString() + ")",
        get_item: (item) => item,
        filter: {
            predicate: (n) => n % 2 === 0,
            onupdate() {
                num_updates += 1;
            },
        },
        $simplebar_container: $scroll_container,
    });

    assert.equal(num_updates, 0);

    assert.deepEqual($container.$appended_data.html(), "(2)(4)");

    widget.replace_list_data([5, 6, 7, 8]);

    assert.equal(num_updates, 1);

    assert.deepEqual($container.$appended_data.html(), "(6)(8)");
});

run_test("opts.get_item", () => {
    const items = {[1]: "one", [2]: "two", [3]: "three", [4]: "four"};

    const list = [1, 2, 3, 4];

    const boring_opts = {
        get_item: (n) => items[n],
    };

    assert.deepEqual(ListWidget.get_filtered_items("whatever", list, boring_opts), [
        "one",
        "two",
        "three",
        "four",
    ]);

    const predicate = (item, value) => item.startsWith(value);

    const predicate_opts = {
        get_item: (n) => items[n],
        filter: {
            predicate,
        },
    };

    assert.deepEqual(ListWidget.get_filtered_items("t", list, predicate_opts), ["two", "three"]);

    const filterer_opts = {
        get_item: (n) => items[n],
        filter: {
            filterer: (items, value) => items.filter((item) => predicate(item, value)),
        },
    };

    assert.deepEqual(ListWidget.get_filtered_items("t", list, filterer_opts), ["two", "three"]);
});

run_test("render item", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    let called;
    $scroll_container.find = (element) => {
        const query = element.selector;
        const expected_queries = [
            `tr[data-item='${INITIAL_RENDER_COUNT}']`,
            `tr[data-item='${INITIAL_RENDER_COUNT - 1}']`,
        ];
        const item = INITIAL_RENDER_COUNT - 1;
        const new_html = `<tr data-item=${item}>updated: ${item}</tr>\n`;
        const regex = new RegExp(`\\<tr data-item=${item}\\>.*?<\\/tr\\>`);
        assert.ok(expected_queries.includes(query));
        if (query.includes(`data-item='${INITIAL_RENDER_COUNT}'`)) {
            // This item is not rendered, so we find nothing so return an empty stub.
            return {
                length: 0,
            };
        }
        return {
            // Return a JQuery stub for the original HTML.
            // We want this to be called when we replace
            // the existing HTML with newly rendered HTML.
            replaceWith($element) {
                assert.equal(new_html, $element.html());
                called = true;
                $container.$appended_data._replace(regex, new_html);
            },
            length: 1,
        };
    };

    const list = Array.from({length: 100}).keys().toArray();

    let text = "initial";
    const get_item = (item) => ({text: `${text}: ${item}`, value: item});

    const widget = ListWidget.create($container, list, {
        name: "replace-list",
        modifier_html: (item) => `<tr data-item=${item.value}>${item.text}</tr>\n`,
        get_item,
        html_selector: (item) => $(`tr[data-item='${item.value}']`),
        $simplebar_container: $scroll_container,
    });
    const item = INITIAL_RENDER_COUNT - 1;

    assert.ok($container.$appended_data.html().includes("<tr data-item=2>initial: 2</tr>"));
    assert.ok($container.$appended_data.html().includes("<tr data-item=3>initial: 3</tr>"));
    text = "updated";
    called = false;
    widget.render_item(get_item(INITIAL_RENDER_COUNT - 1));
    assert.ok(called);
    assert.ok($container.$appended_data.html().includes("<tr data-item=2>initial: 2</tr>"));
    assert.ok(
        $container.$appended_data.html().includes(`<tr data-item=${item}>updated: ${item}</tr>`),
    );

    // Item 80 should not be in the rendered list. (0 indexed)
    assert.ok(
        !$container.$appended_data
            .html()
            .includes(
                `<tr data-item=${INITIAL_RENDER_COUNT}>initial: ${INITIAL_RENDER_COUNT}</tr>`,
            ),
    );
    called = false;
    widget.render_item(get_item(INITIAL_RENDER_COUNT));
    assert.ok(!called);
    widget.render_item(get_item(INITIAL_RENDER_COUNT - 1));
    assert.ok(called);

    // Tests below this are for the corner cases, where we abort the rerender.

    let get_item_called;
    const widget_2 = ListWidget.create($container, list, {
        name: "replace-list",
        modifier_html: (item) => `<tr data-item=${item.value}>${item.text}</tr>\n`,
        get_item(item) {
            get_item_called = true;
            return item;
        },
        $simplebar_container: $scroll_container,
    });

    get_item_called = false;
    widget_2.render_item(item);
    // Test that we didn't try to render the item.
    assert.ok(!get_item_called);

    let rendering_item = false;
    const widget_3 = ListWidget.create($container, list, {
        name: "replace-list",
        modifier_html: (item) => (rendering_item ? undefined : `${item}\n`),
        get_item,
        html_selector: (item) => $(`tr[data-item='${item}']`),
        $simplebar_container: $scroll_container,
    });
    // Once we have initially rendered the widget, change the
    // behavior of the modifier_html function.
    rendering_item = true;
    blueslip.expect("error", "List item is not a string");
    widget_3.render_item(item);
    blueslip.reset();
});

run_test("render advances the offset by the rows appended", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    const widget = ListWidget.create($container, [1, 2, 3], {
        name: "render-offset",
        modifier_html: div,
        get_item: (item) => item,
        $simplebar_container: $scroll_container,
    });
    assert.equal($container.$appended_data.html(), "<div>1</div><div>2</div><div>3</div>");
    assert.ok(widget.all_rendered());

    // The initial render asked for more rows than the list had; the offset
    // must not end up past its end, or items added later would count as
    // rendered and never be appended.
    widget.replace_list_data([1, 2, 3, 4], false);
    widget.filter_and_sort();
    assert.ok(!widget.all_rendered());
    widget.render();
    assert.equal($container.$appended_data.html(), "<div>4</div>");
    assert.ok(widget.all_rendered());
});

run_test("get_rendered_count", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    const widget = ListWidget.create($container, [1, 2, 3], {
        name: "rendered-count",
        modifier_html: div,
        get_item: (item) => item,
        $simplebar_container: $scroll_container,
    });
    assert.equal(widget.get_rendered_count(), 3);

    // Without html_selector, the widget cannot remove the rows of items
    // dropped from the list, so the offset stays past the list's end.
    widget.replace_list_data([1, 2], false);
    widget.filter_and_sort();
    assert.equal(widget.get_rendered_count(), 2);
    assert.deepEqual(widget.get_rendered_list(), [1, 2]);
});

run_test("filter_and_sort removes rows of items no longer listed", () => {
    const list = make_items(100);
    let hidden_items = new Set();
    let render_count = 0;
    const {widget, rows} = make_tracked_widget(list, {
        filter: {predicate: (item) => !hidden_items.has(item)},
        callback_after_render() {
            render_count += 1;
        },
    });
    assert.equal(render_count, 1);
    assert.deepEqual(rows, list.slice(0, INITIAL_RENDER_COUNT));
    assert.ok(!widget.all_rendered());

    // Two rendered items and one not rendered yet get hidden without their
    // rows being updated.
    const hidden_rows = [rows[4], rows.at(-1)];
    hidden_items = new Set([...hidden_rows, list.at(-1)]);
    assert.deepEqual(widget.filter_and_sort(), hidden_rows);
    assert.equal(rows.length, INITIAL_RENDER_COUNT - hidden_rows.length);
    // The rendered list still matches the rows in the DOM, so rendering
    // more continues right after them, duplicating nothing.
    assert.deepEqual(widget.get_rendered_list(), rows);
    widget.render();
    assert.equal(render_count, 2);
    assert.equal(rows.length, list.length - hidden_items.size);
    assert.deepEqual(widget.get_rendered_list(), rows);
    assert.ok(widget.all_rendered());

    // With everything rendered, removing rows calls render() once, so that
    // an emptied list shows its empty-list message.
    hidden_items.add(list[0]);
    assert.deepEqual(widget.filter_and_sort(), [list[0]]);
    assert.equal(render_count, 3);
});

run_test("render_item drops the row of an item moved past the rendered range", () => {
    const list = make_items(100);
    const {widget, rows, stats} = make_tracked_widget(list, {init_sort: (a, b) => a.key - b.key});
    const moved = rows[4];

    // The item now sorts last, past the rendered range: its row goes, with
    // no redraw, and the rendered list still matches the rows in the DOM.
    moved.key = 200;
    widget.filter_and_sort();
    widget.render_item(moved);
    assert.ok(!rows.includes(moved));
    assert.equal(rows.length, INITIAL_RENDER_COUNT - 1);
    assert.equal(stats.redraws, 0);
    assert.deepEqual(widget.get_rendered_list(), rows);

    // Rendering the rest reaches it last, and once.
    widget.render(list.length);
    assert.ok(widget.all_rendered());
    assert.equal(rows.length, list.length);
    assert.equal(rows.at(-1), moved);
});

run_test("render_item moves a row to its item's new position", () => {
    // Three items get new sort keys and a fourth keeps its own. Rerendered
    // in list order, the three rows move and the fourth is replaced in
    // place, with no redraw.
    const list = make_items(50);
    const {widget, rows, stats} = make_tracked_widget(list, {init_sort: (a, b) => a.key - b.key});
    assert.ok(widget.all_rendered());

    const moved_to_first = list[39];
    const unmoved = list[15];
    const moved_to_middle = list[5];
    const middle_predecessor = list[24];
    const moved_to_last = list[7];

    moved_to_first.key = list[0].key - 0.5;
    moved_to_middle.key = middle_predecessor.key + 0.5;
    moved_to_last.key = list.at(-1).key + 0.5;
    widget.filter_and_sort();
    for (const item of [moved_to_first, unmoved, moved_to_middle, moved_to_last]) {
        widget.render_item(item);
    }
    assert.equal(rows[0], moved_to_first);
    assert.equal(rows[rows.indexOf(middle_predecessor) + 1], moved_to_middle);
    assert.equal(rows.at(-1), moved_to_last);
    assert.deepEqual(widget.get_rendered_list(), rows);
    assert.deepEqual(stats, {redraws: 0, replaced: [unmoved]});
});

run_test("render_item moves rows that end up next to each other", () => {
    // Two neighbors move to the front together and two more to the end,
    // each pair keeping its order. They are rerendered in list order, so
    // when a row is placed, the row of the item after it is still where
    // it used to be.
    const list = make_items(50);
    const {widget, rows, stats} = make_tracked_widget(list, {init_sort: (a, b) => a.key - b.key});
    const first_item = list[0];
    const last_item = list.at(-1);
    const moved_to_front = [list[30], list[31]];
    const moved_to_end = [list[10], list[11]];

    moved_to_front[0].key = first_item.key - 0.5;
    moved_to_front[1].key = first_item.key - 0.25;
    moved_to_end[0].key = last_item.key + 0.25;
    moved_to_end[1].key = last_item.key + 0.5;
    widget.filter_and_sort();
    for (const item of [...moved_to_front, ...moved_to_end]) {
        widget.render_item(item);
    }
    assert.deepEqual(rows.slice(0, 2), moved_to_front);
    assert.deepEqual(rows.slice(-2), moved_to_end);
    assert.deepEqual(widget.get_rendered_list(), rows);
    assert.deepEqual(stats, {redraws: 0, replaced: []});
});

run_test("rerendering changed items in list order keeps the rows matching the list", () => {
    // What recent view does when several items change at once: it walks
    // the list in order, rerendering each changed item that has a row and
    // inserting a row for one that has none. Here one item is new, one
    // moves within the rendered rows and one moves past them.
    const list = make_items(100);
    const {widget, rows, stats} = make_tracked_widget(list, {
        filter: {predicate: () => true},
        init_sort: (a, b) => a.key - b.key,
    });
    const new_item_predecessor = list[4];
    const moved_within_range = list[10];
    const new_predecessor_within_range = list[40];
    const moved_past_range = list[20];

    moved_within_range.key = new_predecessor_within_range.key + 0.5;
    moved_past_range.key = list.at(-1).key + 0.5;
    const [new_item] = add_items(widget, list, [new_item_predecessor.key + 0.5]);
    const changed_items = new Set([new_item, moved_within_range, moved_past_range]);
    for (const [index, item] of widget.get_current_list().entries()) {
        if (changed_items.has(item)) {
            if (rows.includes(item)) {
                widget.render_item(item);
            } else {
                widget.insert_rendered_row(item, () => index);
            }
        }
    }
    assert.equal(rows[rows.indexOf(new_item_predecessor) + 1], new_item);
    assert.equal(rows[rows.indexOf(new_predecessor_within_range) + 1], moved_within_range);
    assert.ok(!rows.includes(moved_past_range));
    assert.equal(rows.length, INITIAL_RENDER_COUNT);
    assert.deepEqual(widget.get_rendered_list(), rows);
    assert.deepEqual(stats, {redraws: 0, replaced: []});
});

run_test("render_item redraws when a row's new predecessor has no row yet", () => {
    // The first ten rendered items move to the end of the list, which
    // brings unrendered items into the range the widget counts as
    // rendered until those ten rows are dropped later in the walk. Another
    // row moves to just after them, and has no row to be placed after.
    const list = make_items(100);
    const {widget, rows, stats} = make_tracked_widget(list, {init_sort: (a, b) => a.key - b.key});
    const moved_to_end = list.slice(0, 10);
    const first_unrendered_items = list.slice(INITIAL_RENDER_COUNT, INITIAL_RENDER_COUNT + 5);
    const moved_after_unrendered = list[20];

    for (const [i, item] of moved_to_end.entries()) {
        item.key = list.at(-1).key + 1 + i;
    }
    moved_after_unrendered.key = first_unrendered_items.at(-1).key + 0.5;
    widget.filter_and_sort();
    widget.render_item(moved_after_unrendered);
    assert.equal(stats.redraws, 1);
    assert.equal(rows[rows.indexOf(first_unrendered_items.at(-1)) + 1], moved_after_unrendered);
    assert.equal(rows.length, INITIAL_RENDER_COUNT);
    assert.deepEqual(widget.get_rendered_list(), rows);
});

run_test("insert_rendered_row places a row after its predecessor's row", () => {
    // Two new items sort first and are inserted in list order, like the
    // new conversations of a bulk rerender in recent view. The first has
    // no predecessor, and the second has no row yet when the first is
    // placed.
    const list = make_items(100);
    const {widget, rows, stats} = make_tracked_widget(list, {
        filter: {predicate: () => true},
        init_sort: (a, b) => a.key - b.key,
    });
    const [first_new_item, second_new_item] = add_items(widget, list, [0.1, 0.2]);
    for (const item of [first_new_item, second_new_item]) {
        widget.insert_rendered_row(item, (items) => items.indexOf(item));
    }
    assert.deepEqual(rows.slice(0, 3), [first_new_item, second_new_item, list[0]]);
    assert.equal(rows.length, INITIAL_RENDER_COUNT + 2);
    assert.deepEqual(widget.get_rendered_list(), rows);
    assert.equal(stats.redraws, 0);
});

run_test("insert_rendered_row falls back to a redraw without counting a row", () => {
    const list = make_items(100);
    let hide_all = true;
    const {widget, rows, row, stats} = make_tracked_widget(list, {
        filter: {predicate: () => !hide_all},
        init_sort: (a, b) => a.key - b.key,
    });
    function insert(item) {
        widget.insert_rendered_row(item, (items) => items.indexOf(item));
    }
    assert.equal(rows.length, 0);

    // With no rows rendered, the container may hold the empty-list
    // message, so the widget redraws instead of prepending even the first
    // row. It must not count the row it did not insert.
    hide_all = false;
    widget.filter_and_sort();
    insert(list[0]);
    assert.equal(rows.length, INITIAL_RENDER_COUNT);
    assert.equal(widget.get_rendered_list().length, INITIAL_RENDER_COUNT);

    // The same for a new last item whose predecessor's row went missing.
    widget.render(list.length);
    const neighbor = rows.at(-1);
    row(neighbor).remove();
    const [new_last_item] = add_items(widget, list, [neighbor.key + 0.5]);
    insert(new_last_item);
    assert.equal(stats.redraws, 1);
    assert.ok(!rows.includes(new_last_item));
    assert.equal(rows.length, INITIAL_RENDER_COUNT);
    assert.equal(widget.get_rendered_list().length, INITIAL_RENDER_COUNT);
});

run_test("Multiselect dropdown retain_selected_items", () => {
    const $container = make_container();
    const $scroll_container = make_scroll_container();
    const $filter_element = make_filter_element();
    let data_rendered = [];

    const list = ["one", "two", "three", "four"].map((x) => ({name: x, value: x}));
    const data = ["one"]; // Data initially selected.

    $container.find = (elem) => DropdownItem(elem);

    // We essentially create fake jQuery functions
    // whose return value are stored in objects so that
    // they can be later asserted with expected values.
    function DropdownItem(element) {
        const temp = {};

        function length() {
            if (element) {
                return true;
            }
            /* istanbul ignore next */
            return false;
        }

        function find(tag) {
            return ListItem(tag, temp);
        }

        function addClass(cls) {
            temp.appended_class = cls;
        }

        temp.element = element;
        return {
            length: length(),
            find,
            addClass,
        };
    }

    function ListItem(element, temp) {
        function expectOne() {
            data_rendered.push(temp);
            return ListItem(element, temp);
        }

        function prepend($data) {
            temp.prepended_data = $data.html();
        }

        return {
            expectOne,
            prepend,
        };
    }

    const widget = ListWidget.create($container, list, {
        name: "replace-list",
        modifier_html: (item) => `<li data-value="${item.value}">${item.name}</li>\n`,
        get_item: (item) => item,
        multiselect: {
            selected_items: data,
        },
        filter: {
            $element: $filter_element,
            predicate: () => true,
        },
        $simplebar_container: $scroll_container,
    });

    const expected_value = [
        {
            element: 'li[data-value="one"]',
            appended_class: "checked",
            prepended_data: "<i>",
        },
    ];

    assert.deepEqual(expected_value, data_rendered);

    // Reset the variable and re execute the `widget.render` method.
    data_rendered = [];

    // Making sure!
    assert.deepEqual(data_rendered, []);

    widget.hard_redraw();

    // Expect the `data_rendered` array to be same again.
    assert.deepEqual(expected_value, data_rendered);
});