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.

30.2 KB
Raw Blame
"use strict";

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

const {make_user_group} = require("./lib/example_group.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 {zrequire, mock_esm} = require("./lib/namespace.cjs");
const {run_test} = require("./lib/test.cjs");
const blueslip = require("./lib/zblueslip.cjs");
const {$} = require("./lib/zjquery.cjs");
const {page_params} = require("./lib/zpage_params.cjs");

const noop = function () {};

const bootstrap_typeahead = mock_esm("../src/bootstrap_typeahead");

const input_pill = zrequire("input_pill");
const pill_typeahead = zrequire("pill_typeahead");
const peer_data = zrequire("peer_data");
const people = zrequire("people");
const {set_current_user, set_realm} = zrequire("state_data");
const stream_data = zrequire("stream_data");
const user_groups = zrequire("user_groups");
const typeahead_helper = zrequire("typeahead_helper");

const current_user = {};
set_current_user(current_user);
const realm = make_realm({
    custom_profile_field_types: {
        PRONOUNS: {id: 8},
    },
});
set_realm(realm);

// set global test variables.
let sort_recipients_called = false;
let sort_streams_called = false;
let sort_group_setting_options_called = false;
let sort_stream_or_group_members_options_called = false;
const $fake_rendered_topic_state = $.create("fake-rendered-topic-state");

function override_typeahead_helper({mock_template, override_rewire}) {
    mock_template("typeahead_list_item.hbs", false, (args) => {
        if (args.stream) {
            return "<rendered-stream-stub>";
        }
        if (args.is_user_group) {
            return "<rendered-group-stub>";
        }
        assert.ok(args.is_person);
        return "<rendered-person-stub>";
    });
    override_rewire(typeahead_helper, "sort_streams", () => {
        sort_streams_called = true;
    });
    override_rewire(typeahead_helper, "sort_stream_or_group_members_options", ({users, query}) => {
        assert.ok(!query.startsWith("@"));
        sort_stream_or_group_members_options_called = true;
        return users;
    });
}

function user_item(user) {
    return {type: "user", user};
}

const jill = make_user({
    email: "[email protected]",
    user_id: 10,
    full_name: "Jill Hill",
});
const jill_item = user_item(jill);
const mark = make_user({
    email: "[email protected]",
    user_id: 20,
    full_name: "Marky Mark",
});
const mark_item = user_item(mark);
const fred = make_user({
    email: "[email protected]",
    user_id: 30,
    full_name: "Fred Flintstone",
});
const fred_item = user_item(fred);
const me = make_user({
    email: "[email protected]",
    user_id: 40,
    full_name: "me",
});
const me_item = user_item(me);

const persons = [jill, mark, fred, me];
for (const person of persons) {
    people.add_active_user(person);
}
const person_items = persons.map((person) => user_item(person));

function user_group_item(user_group) {
    return {
        ...user_group,
        type: "user_group",
    };
}

const admins = make_user_group({
    name: "Admins",
    description: "foo",
    id: 1,
    members: new Set([jill.user_id, mark.user_id, me.user_id]),
});
const admins_item = user_group_item(admins);
const testers = make_user_group({
    name: "Testers",
    description: "bar",
    id: 2,
    members: new Set([mark.user_id, fred.user_id, me.user_id]),
});
const testers_item = user_group_item(testers);

const groups = [admins, testers];
for (const group of groups) {
    user_groups.add(group);
}
const group_items = [admins_item, testers_item];

function stream_item(stream) {
    return {
        ...stream,
        type: "stream",
    };
}

const denmark = make_stream({
    stream_id: 1,
    name: "Denmark",
    subscribed: true,
});
const denmark_item = stream_item(denmark);

const sweden = make_stream({
    stream_id: 2,
    name: "Sweden",
    subscribed: false,
});
const sweden_item = stream_item(sweden);

const subs = [denmark, sweden];
for (const sub of subs) {
    stream_data.add_sub_for_tests(sub);
}
peer_data.set_subscribers(denmark.stream_id, [me.user_id, mark.user_id]);
peer_data.set_subscribers(sweden.stream_id, [mark.user_id, jill.user_id]);

run_test("set_up_user", ({mock_template, override, override_rewire}) => {
    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.ok(args.is_person);
        return "<rendered-person-stub>";
    });
    override_rewire(typeahead_helper, "sort_recipients", ({users}) => {
        sort_recipients_called = true;
        return users;
    });
    mock_template("input_pill.hbs", true, (_data, html) => html);
    let input_pill_typeahead_called = false;
    const $fake_input = $.create(".input");
    $fake_input[0].before = noop;

    const $container = $.create(".pill-container");
    $container.set_find_results(".input", $fake_input);

    const $pill_widget = input_pill.create({
        $container,
        create_item_from_text: noop,
        get_text_from_item: noop,
        get_display_value_from_item: noop,
    });

    override(bootstrap_typeahead, "Typeahead", (input_element, config) => {
        assert.equal(input_element.$element, $fake_input);
        assert.ok(config.dropup);
        assert.ok(config.stopAdvance);

        assert.equal(typeof config.source, "function");
        assert.equal(typeof config.item_html, "function");
        assert.equal(typeof config.matcher, "function");
        assert.equal(typeof config.sorter, "function");
        assert.equal(typeof config.updater, "function");

        // test queries
        const person_query = "me";

        (function test_item_html() {
            assert.equal(config.item_html(person_query)(me_item), "<rendered-person-stub>");
        })();

        (function test_matcher() {
            let result = config.matcher(person_query)(me_item);
            assert.ok(result);
            result = config.matcher(person_query)(jill_item);
            assert.ok(!result);
        })();

        (function test_sorter() {
            sort_recipients_called = false;
            config.sorter([me_item], person_query);
            assert.ok(sort_recipients_called);
        })();

        (function test_source() {
            let expected_result = [];
            const result = config.source(person_query);
            const actual_result = result.map((item) => item.user_id);
            expected_result = [...expected_result, ...person_items];
            expected_result = expected_result.map((item) => item.user_id);
            assert.deepEqual(actual_result, expected_result);
        })();

        (function test_updater() {
            function number_of_pills() {
                const pills = $pill_widget.items();
                return pills.length;
            }
            assert.equal(number_of_pills(), 0);
            config.updater(me_item, person_query);
            assert.equal(number_of_pills(), 1);
        })();

        // input_pill_typeahead_called is set true if
        // no exception occurs in pill_typeahead.set_up_user.
        input_pill_typeahead_called = true;
    });

    pill_typeahead.set_up_user($fake_input, $pill_widget, {});
    assert.ok(input_pill_typeahead_called);
});

run_test("set_up_stream", ({mock_template, override, override_rewire}) => {
    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.ok(args.stream !== undefined);
        return "<rendered-stream-stub>";
    });
    override_rewire(typeahead_helper, "sort_streams_by_name", ({streams}) => {
        sort_streams_called = true;
        return streams;
    });
    mock_template("input_pill.hbs", true, (_data, html) => html);
    let input_pill_typeahead_called = false;
    const $fake_input = $.create(".input");
    $fake_input[0].before = noop;

    const $container = $.create(".pill-container");
    $container.set_find_results(".input", $fake_input);

    const $pill_widget = input_pill.create({
        $container,
        create_item_from_text: noop,
        get_text_from_item: noop,
        get_display_value_from_item: noop,
    });

    override(bootstrap_typeahead, "Typeahead", (input_element, config) => {
        assert.equal(input_element.$element, $fake_input);
        assert.ok(config.dropup);
        assert.ok(config.stopAdvance);

        assert.equal(typeof config.source, "function");
        assert.equal(typeof config.item_html, "function");
        assert.equal(typeof config.matcher, "function");
        assert.equal(typeof config.sorter, "function");
        assert.equal(typeof config.updater, "function");
        assert.equal(config.helpOnEmptyStrings(), false);

        // test queries
        const stream_query = "#denmark";

        (function test_item_html() {
            assert.equal(config.item_html(stream_query)(denmark_item), "<rendered-stream-stub>");
        })();

        (function test_matcher() {
            let result = config.matcher(stream_query)(denmark_item);
            assert.ok(result);
            result = config.matcher(stream_query)(sweden_item);
            assert.ok(!result);
        })();

        (function test_sorter() {
            sort_streams_called = false;
            config.sorter([denmark_item], stream_query);
            assert.ok(sort_streams_called);
        })();

        (function test_source() {
            const result = config.source(stream_query);
            const stream_ids = result.map((stream) => stream.stream_id);
            const expected_stream_ids = [denmark.stream_id, sweden.stream_id];
            assert.deepEqual(stream_ids, expected_stream_ids);
        })();

        (function test_updater() {
            function number_of_pills() {
                const pills = $pill_widget.items();
                return pills.length;
            }
            assert.equal(number_of_pills(), 0);
            config.updater(denmark_item, stream_query);
            assert.equal(number_of_pills(), 1);
        })();

        // input_pill_typeahead_called is set true if
        // no exception occurs in pill_typeahead.set_up_user.
        input_pill_typeahead_called = true;
    });

    pill_typeahead.set_up_stream($fake_input, $pill_widget, {});
    assert.ok(input_pill_typeahead_called);
});

run_test("set_up_user_group", ({mock_template, override, override_rewire}) => {
    current_user.user_id = me.user_id;
    current_user.full_name = me.full_name;
    current_user.email = me.email;
    let sort_user_groups_called = false;

    override_rewire(typeahead_helper, "render_user_group", () => "<rendered-group-stub>");
    override_rewire(typeahead_helper, "sort_user_groups", ({user_groups}) => {
        sort_user_groups_called = true;
        return user_groups;
    });

    mock_template("input_pill.hbs", true, (_data, html) => html);

    let input_pill_typeahead_called = false;
    const $fake_input = $.create(".input");
    $fake_input[0].before = noop;

    const $container = $.create(".pill-container");
    $container.set_find_results(".input", $fake_input);

    const $pill_widget = input_pill.create({
        $container,
        create_item_from_text: noop,
        get_text_from_item: noop,
        get_display_value_from_item: noop,
    });

    const user_group_source = () => [admins_item, testers_item];

    override(bootstrap_typeahead, "Typeahead", (input_element, config) => {
        current_user.user_id = me.user_id;
        current_user.full_name = me.full_name;
        current_user.email = me.email;
        assert.equal(input_element.$element, $fake_input);
        assert.ok(config.dropup);
        assert.ok(config.stopAdvance);

        assert.equal(typeof config.source, "function");
        assert.equal(typeof config.item_html, "function");
        assert.equal(typeof config.matcher, "function");
        assert.equal(typeof config.sorter, "function");
        assert.equal(typeof config.updater, "function");
        assert.equal(config.helpOnEmptyStrings(), true);

        const group_query = "testers";

        (function test_item_html() {
            assert.equal(config.item_html(group_query)(testers_item), "<rendered-group-stub>");
        })();

        (function test_matcher() {
            let result = config.matcher(group_query)(testers_item);
            assert.ok(result);
            result = config.matcher(group_query)(admins_item);
            assert.ok(!result);
        })();

        (function test_sorter() {
            sort_user_groups_called = false;
            config.sorter([testers_item], group_query);
            assert.ok(sort_user_groups_called);
        })();

        (function test_source() {
            const result = config.source(group_query);
            const group_names = result.map((group) => group.name);
            const expected_group_names = ["Admins", "Testers"];
            assert.deepEqual(group_names, expected_group_names);
        })();

        (function test_updater() {
            function number_of_pills() {
                const pills = $pill_widget.items();
                return pills.length;
            }
            assert.equal(number_of_pills(), 0);
            config.updater(testers_item, "<rendered-group-stub>");
            assert.equal(number_of_pills(), 1);
        })();

        input_pill_typeahead_called = true;
    });

    pill_typeahead.set_up_user_group($fake_input, $pill_widget, {user_group_source});
    assert.ok(input_pill_typeahead_called);
});

run_test("render_topic_state", ({override_rewire}) => {
    override_rewire(typeahead_helper, "render_typeahead_item", (args) => {
        assert.equal(args.primary, "Resolved");
        return $fake_rendered_topic_state;
    });

    const result = typeahead_helper.render_topic_state("Resolved");
    assert.equal(result, $fake_rendered_topic_state);

    override_rewire(typeahead_helper, "render_topic_state", (state) => `${state}`);

    const new_result = typeahead_helper.render_topic_state("Unresolved");
    assert.equal(new_result, "Unresolved");
});

run_test("set_up_combined", ({mock_template, override, override_rewire}) => {
    override_typeahead_helper({mock_template, override_rewire});
    mock_template("input_pill.hbs", true, (_data, html) => html);
    let input_pill_typeahead_called = false;
    const $fake_input = $.create(".input");
    $fake_input[0].before = noop;

    const $container = $.create(".pill-container");
    $container.set_find_results(".input", $fake_input);

    const $pill_widget = input_pill.create({
        $container,
        create_item_from_text: noop,
        get_text_from_item: noop,
        get_display_value_from_item: noop,
    });

    function mock_pill_removes(widget) {
        const pills = widget._get_pills_for_testing();
        for (const pill of pills) {
            pill.$element[0].remove = noop;
        }
    }

    let opts = {};
    override(bootstrap_typeahead, "Typeahead", (input_element, config) => {
        assert.equal(input_element.$element, $fake_input);
        assert.ok(config.dropup);
        assert.ok(config.stopAdvance);

        assert.equal(typeof config.source, "function");
        assert.equal(typeof config.item_html, "function");
        assert.equal(typeof config.matcher, "function");
        assert.equal(typeof config.sorter, "function");
        assert.equal(typeof config.updater, "function");
        assert.equal(config.helpOnEmptyStrings(), true);

        // test queries
        const stream_query = "#Denmark";
        const person_query = "me";
        const group_query = "test";

        (function test_item_html() {
            if (opts.stream) {
                // Test stream item_html for widgets that allow stream pills.
                assert.equal(
                    config.item_html(stream_query)(denmark_item),
                    "<rendered-stream-stub>",
                );
            }
            if (opts.user_group && opts.user) {
                // If user is also allowed along with user_group
                // then we should check that each of them rendered correctly.
                assert.equal(config.item_html(group_query)(testers_item), "<rendered-group-stub>");
                assert.equal(config.item_html(person_query)(me_item), "<rendered-person-stub>");
            }
            if (opts.user && !opts.user_group) {
                assert.equal(config.item_html(person_query)(me_item), "<rendered-person-stub>");
            }
            if (!opts.user && opts.user_group) {
                assert.equal(config.item_html(group_query)(testers_item), "<rendered-group-stub>");
            }
        })();

        (function test_matcher() {
            let result;
            if (opts.stream) {
                result = config.matcher(stream_query)(denmark_item);
                assert.ok(result);
                result = config.matcher(stream_query)(sweden_item);
                assert.ok(!result);
            }
            if (opts.user_group && opts.user) {
                /* If user pills are also allowed along with user groups.
                We should check that queries matching either a person
                or group is returned. */

                // group query, with correct item.
                result = config.matcher(group_query)(testers_item);
                assert.ok(result);
                // group query, with wrong item.
                result = config.matcher(group_query)(admins_item);
                assert.ok(!result);
                // person query with correct item.
                result = config.matcher(person_query)(me_item);
                assert.ok(result);
                // person query with wrong item.
                result = config.matcher(person_query)(jill_item);
                assert.ok(!result);
                // @-prefixed query matches groups only.
                result = config.matcher("@" + group_query)(testers_item);
                assert.ok(result);
                result = config.matcher("@admins")(admins_item);
                assert.ok(result);
                // @-prefixed query must NOT match users.
                result = config.matcher("@" + person_query)(me_item);
                assert.ok(!result);
            }
            if (opts.user_group && !opts.user) {
                result = config.matcher(group_query)(testers_item);
                assert.ok(result);
                result = config.matcher(group_query)(admins_item);
                assert.ok(!result);
            }
            if (opts.user && !opts.user_group) {
                result = config.matcher(person_query)(me_item);
                assert.ok(result);
                result = config.matcher(person_query)(jill_item);
                assert.ok(!result);
            }
        })();

        (function test_sorter() {
            if (opts.stream) {
                sort_streams_called = false;
                config.sorter([denmark_item], stream_query);
                assert.ok(sort_streams_called);
            }
            if (opts.user_group) {
                sort_recipients_called = false;
                sort_stream_or_group_members_options_called = false;
                config.sorter([testers_item], group_query);
                assert.ok(!sort_recipients_called);
                assert.ok(sort_stream_or_group_members_options_called);

                // Ensure @-prefixed queries use normalized query in sorter.
                sort_stream_or_group_members_options_called = false;
                config.sorter([testers_item], "@" + group_query);
                assert.ok(sort_stream_or_group_members_options_called);
            }
            if (opts.user) {
                sort_recipients_called = false;
                sort_stream_or_group_members_options_called = false;
                config.sorter([me_item], person_query);
                assert.ok(!sort_recipients_called);
                assert.ok(sort_stream_or_group_members_options_called);
            }
        })();

        (function test_source() {
            let result;
            if (opts.stream) {
                result = config.source(stream_query);
                const stream_ids = result.map((stream) => stream.stream_id);
                const expected_stream_ids = [denmark.stream_id, sweden.stream_id];
                assert.deepEqual(stream_ids, expected_stream_ids);
            }

            let expected_result = [];
            function is_group(item) {
                return item.members;
            }
            result = config.source(person_query);
            const actual_result = result
                .map((item) => {
                    if (is_group(item)) {
                        return item.id;
                    }
                    return item.user_id;
                })
                .filter(Boolean);
            if (opts.user_group) {
                if (opts.user_group_source) {
                    expected_result = [...expected_result, ...opts.user_group_source()];
                } else {
                    expected_result = [...expected_result, ...group_items];
                }
            }
            if (opts.user) {
                if (opts.user_source) {
                    expected_result = [...expected_result, ...opts.user_source()];
                } else {
                    expected_result = [...expected_result, ...person_items];
                }
            }
            expected_result = expected_result
                .map((item) => {
                    if (is_group(item)) {
                        return item.id;
                    }
                    return item.user_id;
                })
                .filter(Boolean);
            assert.deepEqual(actual_result, expected_result);

            if (opts.user_group) {
                const result = config.source("@" + group_query);
                assert.ok(result.length > 0);
                // Source returns only user groups for @-prefixed queries.
                assert.ok(result.every((item) => item.type === "user_group"));
            }
        })();

        (function test_updater() {
            if (opts.user && opts.user_group && opts.stream) {
                // Test it only for the case when all types of pills
                // are allowed, as it would be difficult to keep track
                // of number of items as we call with different types multiple
                // times in this test. So this case checks all possible cases handled by
                // updater in pill_typeahead.

                function number_of_pills() {
                    const pills = $pill_widget.items();
                    return pills.length;
                }
                assert.equal(number_of_pills(), 0);
                config.updater(denmark_item, stream_query);
                assert.equal(number_of_pills(), 1);
                config.updater(me_item, person_query);
                assert.equal(number_of_pills(), 2);
                config.updater(testers_item, group_query);
                assert.equal(number_of_pills(), 3);

                // Clear pills for the next test.
                mock_pill_removes($pill_widget);
                $pill_widget.clear();
            }
        })();

        // input_pill_typeahead_called is set true if
        // no exception occurs in pill_typeahead.set_up_combined.
        input_pill_typeahead_called = true;
    });

    function test_pill_typeahead(opts) {
        pill_typeahead.set_up_combined($fake_input, $pill_widget, opts);
        assert.ok(input_pill_typeahead_called);
    }

    const all_possible_opts = [
        // These are various possible cases of opts that
        // currently occur in web-app codebase. This list
        // can be extended if some other configuration
        // is added later and its logic is to be tested.

        {user: true},
        // user and custom user source.
        {user: true, user_source: () => [fred_item, mark_item]},
        {stream: true},
        {user_group: true},
        // user and custom user group source.
        {user_group: true, user_group_source: () => [admins_item]},
        {user_group: true, stream: true},
        {user_group: true, user: true},
        {user: true, stream: true},
        {user_group: true, stream: true, user: true},
    ];

    for (const config of all_possible_opts) {
        opts = config;
        test_pill_typeahead(config);
    }

    // Special case to test coverage and to test
    // that we enforce type is always specified
    // by caller.
    opts = {};
    input_pill_typeahead_called = false;
    blueslip.expect("error", "Unspecified possible item types");
    pill_typeahead.set_up_combined($fake_input, $pill_widget, {});
    assert.ok(!input_pill_typeahead_called);
});

run_test("set_up_group_setting_typeahead", ({mock_template, override, override_rewire}) => {
    mock_template("typeahead_list_item.hbs", false, (args) => {
        if (args.is_user_group) {
            return "<rendered-group-stub>";
        }
        assert.ok(args.is_person);
        return "<rendered-person-stub>";
    });
    override_rewire(typeahead_helper, "sort_group_setting_options", () => {
        sort_group_setting_options_called = true;
    });
    mock_template("input_pill.hbs", true, (_data, html) => html);

    let input_pill_typeahead_called = false;
    const $fake_input = $.create(".input");
    $fake_input[0].before = noop;

    const $container = $.create(".pill-container");
    $container.set_find_results(".input", $fake_input);

    const $pill_widget = input_pill.create({
        $container,
        create_item_from_text: noop,
        get_text_from_item: noop,
        get_display_value_from_item: noop,
    });

    override(realm, "server_supported_permission_settings", {
        group: {
            can_manage_group: {
                require_system_group: false,
                allow_internet_group: false,
                allow_nobody_group: true,
                allow_everyone_group: false,
                allowed_system_groups: ["role:moderators", "role:nobody", "role:fullmembers"],
            },
        },
    });

    const moderators_system_group = make_user_group({
        name: "role:moderators",
        id: 3,
        description: "Moderators",
        members: [],
        is_system_group: true,
    });
    const nobody_system_group = make_user_group({
        name: "role:nobody",
        id: 4,
        description: "Nobody",
        members: [],
        is_system_group: true,
    });
    const full_members_system_group = make_user_group({
        name: "role:fullmembers",
        id: 5,
        description: "Full members",
        members: [],
        is_system_group: true,
    });
    user_groups.add(moderators_system_group);
    user_groups.add(nobody_system_group);
    user_groups.add(full_members_system_group);

    const moderators_item = user_group_item(moderators_system_group);
    const system_group_items = [moderators_item];

    page_params.development_environment = true;
    override(realm, "realm_waiting_period_threshold", 0);

    override(bootstrap_typeahead, "Typeahead", (input_element, config) => {
        assert.equal(input_element.$element, $fake_input);
        assert.ok(config.dropup);
        assert.ok(config.stopAdvance);

        assert.equal(typeof config.source, "function");
        assert.equal(typeof config.item_html, "function");
        assert.equal(typeof config.matcher, "function");
        assert.equal(typeof config.sorter, "function");
        assert.equal(typeof config.updater, "function");
        assert.equal(config.helpOnEmptyStrings(), true);

        // test queries
        const person_query = "me";
        const group_query = "test";

        (function test_item_html() {
            // If user is also allowed along with user_group
            // then we should check that each of them rendered correctly.
            assert.equal(config.item_html(group_query)(testers_item), "<rendered-group-stub>");
            assert.equal(config.item_html(person_query)(me_item), "<rendered-person-stub>");
        })();

        (function test_matcher() {
            // group query, with correct item.
            let result = config.matcher(group_query)(testers_item);
            assert.ok(result);
            // group query, with wrong item.
            result = config.matcher(group_query)(admins_item);
            assert.ok(!result);
            // person query with correct item.
            result = config.matcher(person_query)(me_item);
            assert.ok(result);
            // person query with wrong item.
            result = config.matcher(person_query)(jill_item);
            assert.ok(!result);
        })();

        (function test_sorter() {
            sort_group_setting_options_called = false;
            config.sorter([testers_item], group_query);
            assert.ok(sort_group_setting_options_called);
            sort_group_setting_options_called = false;
            config.sorter([me_item], person_query);
            assert.ok(sort_group_setting_options_called);
        })();

        (function test_source() {
            let expected_result = [];
            function is_group(item) {
                return item.members;
            }
            const result = config.source(person_query);
            const actual_result = result
                .map((item) => {
                    if (is_group(item)) {
                        return item.id;
                    }
                    return item.user_id;
                })
                .filter(Boolean);
            expected_result = [...expected_result, ...system_group_items, ...group_items];
            expected_result = [...expected_result, ...person_items];
            expected_result = expected_result
                .map((item) => {
                    if (is_group(item)) {
                        return item.id;
                    }
                    return item.user_id;
                })
                .filter(Boolean);
            assert.deepEqual(actual_result, expected_result);
        })();

        (function test_updater() {
            function number_of_pills() {
                const pills = $pill_widget.items();
                return pills.length;
            }
            assert.equal(number_of_pills(), 0);
            config.updater(me_item, person_query);
            assert.equal(number_of_pills(), 1);
            config.updater(testers_item, group_query);
            assert.equal(number_of_pills(), 2);
        })();

        input_pill_typeahead_called = true;
    });

    const opts = {
        setting_name: "can_manage_group",
        setting_type: "group",
        group: testers,
    };
    pill_typeahead.set_up_group_setting_typeahead($fake_input, $pill_widget, opts);
    assert.ok(input_pill_typeahead_called);
});