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.

29.5 KB
Raw Blame
"use strict";

/*
    This mostly tests the peer_data module, but it
    also tests some stream_data functions that are
    glorified wrappers for peer_data functions.
*/

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

const {make_user_group} = require("./lib/example_group.cjs");
const {make_realm} = require("./lib/example_realm.cjs");
const {server_supported_permission_settings} = require("./lib/example_settings.cjs");
const {make_stream} = require("./lib/example_stream.cjs");
const {make_bot, make_cross_realm_bot, make_user, Role} = require("./lib/example_user.cjs");
const {mock_channel_get} = require("./lib/mock_channel.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 {page_params} = require("./lib/zpage_params.cjs");

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

const {GENERIC_BOT_TYPE_INT, INCOMING_WEBHOOK_BOT_TYPE_INT} = zrequire("bot_type_values");
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");

set_current_user({});
const realm = make_realm();
set_realm(realm);

page_params.realm_users = [];
const me = make_user({
    email: "[email protected]",
    full_name: "Current User",
    user_id: 100,
});
// set up user data
const fred = make_user({
    email: "[email protected]",
    full_name: "Fred",
    user_id: 101,
});
const gail = make_user({
    email: "[email protected]",
    full_name: "Gail",
    user_id: 102,
});
const george = make_user({
    email: "[email protected]",
    full_name: "George",
    user_id: 103,
});
const bot_botson = make_bot({
    email: "[email protected]",
    user_id: 35,
    full_name: "Bot Botson",
    role: Role.MODERATOR,
});

const nobody_group = make_user_group({
    name: "Nobody",
    id: 1,
    members: new Set(),
    is_system_group: true,
    direct_subgroup_ids: new Set(),
});

function contains_sub(subs, sub) {
    return subs.some((s) => s.name === sub.name);
}
function test(label, f) {
    run_test(label, ({override, override_rewire}) => {
        peer_data.clear_for_testing();
        stream_data.clear_subscriptions();
        people.init();
        people.add_active_user(me);
        people.initialize_current_user(me.user_id);

        user_groups.initialize({
            realm_user_groups: [nobody_group],
        });
        override(
            realm,
            "server_supported_permission_settings",
            server_supported_permission_settings,
        );
        override(realm, "realm_can_access_all_users_group", nobody_group.id);

        return f({override, override_rewire});
    });
}

test("unsubscribe", ({override_rewire}) => {
    const devel = make_stream({
        name: "devel",
        subscribed: false,
        stream_id: 1,
    });

    stream_data.add_sub_for_tests(devel);

    // verify clean slate
    assert.ok(!stream_data.is_subscribed(devel.stream_id));

    // set up our subscription
    devel.subscribed = true;
    peer_data.set_subscribers(devel.stream_id, [me.user_id]);

    // ensure our setup is accurate
    assert.ok(stream_data.is_subscribed(devel.stream_id));

    override_rewire(stream_data, "set_max_channel_width_css_variable", noop);
    // DO THE UNSUBSCRIBE HERE
    stream_data.unsubscribe_myself(devel);
    assert.ok(!devel.subscribed);
    assert.ok(!stream_data.is_subscribed(devel.stream_id));
    assert.ok(!contains_sub(stream_data.subscribed_subs(), devel));
    assert.ok(contains_sub(stream_data.unsubscribed_subs(), devel));

    // make sure subsequent calls work
    const sub = stream_data.get_sub("devel");
    assert.ok(!sub.subscribed);
});

test("subscribers", async () => {
    const sub = make_stream({
        name: "Rome",
        subscribed: true,
        stream_id: 1001,
        can_add_subscribers_group: nobody_group.id,
        can_administer_channel_group: nobody_group.id,
        can_subscribe_group: nobody_group.id,
    });
    stream_data.add_sub_for_tests(sub);

    people.add_active_user(fred);
    people.add_active_user(gail);
    people.add_active_user(george);

    // verify setup
    assert.ok(stream_data.is_subscribed(sub.stream_id));

    const stream_id = sub.stream_id;

    function potential_subscriber_ids() {
        const users = peer_data.potential_subscribers(stream_id);
        return users.map((u) => u.user_id).toSorted();
    }

    blueslip.expect(
        "error",
        "Fetching potential subscribers for stream without full subscriber data",
    );
    potential_subscriber_ids();
    blueslip.reset();

    const bogus_stream_id = 999;
    blueslip.expect(
        "warn",
        "We called set_subscribers for an untracked stream: " + bogus_stream_id,
    );
    peer_data.set_subscribers(bogus_stream_id, []);
    blueslip.reset();

    peer_data.set_subscribers(stream_id, []);
    assert.deepEqual(potential_subscriber_ids(), [
        me.user_id,
        fred.user_id,
        gail.user_id,
        george.user_id,
    ]);

    peer_data.set_subscribers(stream_id, [me.user_id, fred.user_id, george.user_id]);
    assert.ok(stream_data.is_user_loaded_and_subscribed(stream_id, me.user_id));
    assert.ok(stream_data.is_user_loaded_and_subscribed(stream_id, fred.user_id));
    assert.ok(stream_data.is_user_loaded_and_subscribed(stream_id, george.user_id));
    assert.ok(!stream_data.is_user_loaded_and_subscribed(stream_id, gail.user_id));

    assert.deepEqual(potential_subscriber_ids(), [gail.user_id]);

    peer_data.set_subscribers(stream_id, []);

    const brutus = make_user({
        email: "[email protected]",
        full_name: "Brutus",
        user_id: 104,
    });
    people.add_active_user(brutus);
    assert.ok(!stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));

    // add
    peer_data.add_subscriber(stream_id, brutus.user_id);
    assert.ok(stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));
    assert.equal(peer_data.get_subscriber_count(stream_id), 1);

    // verify that adding an already-added subscriber is a noop
    peer_data.add_subscriber(stream_id, brutus.user_id);
    assert.ok(stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));
    assert.equal(peer_data.get_subscriber_count(stream_id), 1);

    // remove
    peer_data.remove_subscriber(stream_id, brutus.user_id);
    assert.ok(!stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));
    assert.equal(peer_data.get_subscriber_count(stream_id), 0);

    // Verify noop for bad stream when removing subscriber
    const bad_stream_id = 999999;
    blueslip.expect(
        "warn",
        "We called get_loaded_subscriber_subset for an untracked stream: " + bad_stream_id,
    );
    blueslip.expect(
        "error",
        "We called decrement_subscriber_count for an untracked stream: " + bad_stream_id,
    );
    peer_data.remove_subscriber(bad_stream_id, brutus.user_id);
    blueslip.reset();

    // verify that removing an already-removed subscriber is a noop
    peer_data.remove_subscriber(stream_id, brutus.user_id);
    assert.ok(!stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));
    assert.equal(peer_data.get_subscriber_count(stream_id), 0);

    // Verify defensive code in set_subscribers, where the second parameter
    // can be undefined.
    stream_data.add_sub_for_tests(sub);
    peer_data.add_subscriber(stream_id, brutus.user_id);
    sub.subscribed = true;
    assert.ok(stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));

    // Verify that we noop and don't crash when unsubscribed.
    sub.subscribed = false;
    peer_data.add_subscriber(stream_id, brutus.user_id);
    assert.equal(stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id), true);
    peer_data.remove_subscriber(stream_id, brutus.user_id);
    assert.equal(stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id), false);
    peer_data.add_subscriber(stream_id, brutus.user_id);
    assert.equal(stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id), true);

    blueslip.expect(
        "warn",
        "We got a is_user_subscribed call for a non-existent or inaccessible stream.",
        2,
    );
    sub.invite_only = true;
    assert.ok(!stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));
    peer_data.remove_subscriber(stream_id, brutus.user_id);
    assert.ok(!stream_data.is_user_loaded_and_subscribed(stream_id, brutus.user_id));
    blueslip.reset();

    // Same test but for `maybe_fetch_is_user_subscribed`
    blueslip.expect(
        "warn",
        "We got a maybe_fetch_is_user_subscribed call for a non-existent or inaccessible stream.",
        2,
    );
    peer_data.add_subscriber(stream_id, brutus.user_id);
    assert.ok(!(await stream_data.maybe_fetch_is_user_subscribed(stream_id, brutus.user_id)));
    peer_data.remove_subscriber(stream_id, brutus.user_id);
    assert.ok(!(await stream_data.maybe_fetch_is_user_subscribed(stream_id, brutus.user_id)));
    blueslip.reset();

    // Verify that we don't crash for a bad stream.
    blueslip.expect(
        "warn",
        "We called get_loaded_subscriber_subset for an untracked stream: 9999999",
    );
    blueslip.expect(
        "error",
        "We called increment_subscriber_count for an untracked stream: 9999999",
    );
    peer_data.add_subscriber(9999999, brutus.user_id);
    blueslip.reset();

    // Verify that we don't crash for a bad user id.
    blueslip.expect("error", "Unknown user_id in maybe_get_user_by_id");
    blueslip.expect("warn", "We tried to add invalid subscriber: 88888");
    peer_data.add_subscriber(stream_id, 88888);
    blueslip.reset();
});

test("maybe_fetch_stream_subscribers", async () => {
    const india = make_stream({
        stream_id: 102,
        name: "India",
        subscribed: true,
    });
    stream_data.add_sub_for_tests(india);
    let channel_get_calls = 0;
    mock_channel_get(channel, (opts) => {
        assert.equal(opts.url, `/json/streams/${india.stream_id}/members`);
        channel_get_calls += 1;
        opts.success({
            subscribers: [1, 2, 3, 4],
        });
    });

    // Only one of these will do the fetch, and the other will wait
    // for the first fetch to complete.
    const promise1 = peer_data.fetch_stream_subscribers(india.stream_id);
    const promise2 = peer_data.fetch_stream_subscribers(india.stream_id);
    await promise1;
    await promise2;
    assert.equal(channel_get_calls, 1);

    peer_data.clear_for_testing();
    const pending_promise = peer_data.fetch_stream_subscribers(india.stream_id, false);
    peer_data.bulk_add_subscribers({
        stream_ids: [india.stream_id],
        user_ids: [7, 9],
    });
    peer_data.bulk_remove_subscribers({
        stream_ids: [india.stream_id],
        user_ids: [3],
    });
    blueslip.expect("error", "Getting subscribers for stream without full subscriber data");
    const subscribers_before_fetch_completes = peer_data.get_subscriber_ids_assert_loaded(
        india.stream_id,
    );
    blueslip.reset();
    assert.deepEqual(subscribers_before_fetch_completes, [7, 9]);
    const subscribers_after_fetch = await pending_promise;
    assert.deepEqual(subscribers_after_fetch.keys().toArray(), [1, 2, 4, 7, 9]);

    peer_data.clear_for_testing();
    assert.equal(await peer_data.maybe_fetch_is_user_subscribed(india.stream_id, 2, false), true);
    assert.equal(peer_data.has_full_subscriber_data(india.stream_id), true);

    peer_data.clear_for_testing();
    assert.equal(peer_data.has_full_subscriber_data(india.stream_id), false);
    assert.equal(await peer_data.maybe_fetch_is_user_subscribed(india.stream_id, 2, false), true);
    assert.equal(await peer_data.maybe_fetch_is_user_subscribed(india.stream_id, 5, false), false);

    peer_data.clear_for_testing();
    blueslip.expect("error", "Getting subscribers for stream without full subscriber data");
    assert.deepEqual(await peer_data.get_subscriber_ids_assert_loaded(india.stream_id), []);
    blueslip.reset();
    assert.deepEqual(
        await peer_data.get_subscribers_with_possible_fetch(india.stream_id),
        [1, 2, 3, 4],
    );

    peer_data.clear_for_testing();
    mock_channel_get(channel, (opts) => {
        opts.error({status: 400, responseJSON: ""});
    });
    blueslip.expect("error", "Bad request to fetch channel subscribers.");
    // retry is false, so we get null because there was an error
    assert.deepEqual(
        await peer_data.get_subscribers_with_possible_fetch(india.stream_id, false),
        null,
    );
    blueslip.reset();

    // A bad request is not retried, so we get null even with retry.
    blueslip.expect("error", "Bad request to fetch channel subscribers.");
    assert.deepEqual(
        await peer_data.get_subscribers_with_possible_fetch(india.stream_id, true),
        null,
    );
    blueslip.reset();

    peer_data.clear_for_testing();
    mock_channel_get(channel, (opts) => {
        opts.error({readyState: 0});
    });
    // null because there was an error, but no blueslip error for readystate 0
    assert.deepEqual(
        await peer_data.get_subscribers_with_possible_fetch(india.stream_id, false),
        null,
    );

    peer_data.clear_for_testing();
    mock_channel_get(channel, (opts) => {
        opts.error({status: 500, responseJSON: ""});
    });
    blueslip.expect("error", "Failure fetching channel subscribers");
    // retry is false, so we get null because there was an error
    assert.deepEqual(
        await peer_data.get_subscribers_with_possible_fetch(india.stream_id, false),
        null,
    );
    blueslip.reset();

    peer_data.clear_for_testing();
    mock_channel_get(channel, (opts) => {
        opts.error({status: 500, responseJSON: ""});
    });
    blueslip.expect("error", "Failure fetching channel subscribers");
    assert.equal(await peer_data.maybe_fetch_is_user_subscribed(india.stream_id, 5, false), null);
    blueslip.reset();

    // If we know they're subscribed, we return `true` even though we don't have complete
    // data.
    peer_data.bulk_add_subscribers({
        stream_ids: [india.stream_id],
        user_ids: [5],
    });
    blueslip.expect("error", "Failure fetching channel subscribers");
    assert.equal(await peer_data.maybe_fetch_is_user_subscribed(india.stream_id, 5, false), true);
    blueslip.reset();

    peer_data.clear_for_testing();
    set_global("setTimeout", (f) => {
        f();
    });
    let num_attempts = 0;
    mock_channel_get(channel, (opts) => {
        num_attempts += 1;
        if (num_attempts === 2) {
            opts.success({
                subscribers: [1, 2, 3, 4],
            });
        } else {
            opts.error({status: 500, responseJSON: ""});
        }
    });
    blueslip.expect("error", "Failure fetching channel subscribers");
    const subscribers = await peer_data.fetch_stream_subscribers_with_retry(india.stream_id);
    assert.equal(num_attempts, 2);
    assert.deepEqual(subscribers.keys().toArray(), [1, 2, 3, 4]);
    blueslip.reset();

    peer_data.clear_for_testing();
    blueslip.expect("error", "Failure fetching channel subscribers");
    num_attempts = 0;
    assert.equal(await peer_data.maybe_fetch_is_user_subscribed(india.stream_id, 5, true), false);
    assert.equal(num_attempts, 2);

    // No retry if it's a bad request
    num_attempts = 0;
    mock_channel_get(channel, (opts) => {
        num_attempts += 1;
        assert.equal(num_attempts, 1);
        opts.error({status: 400, responseJSON: "bad request"});
    });
    peer_data.clear_for_testing();
    blueslip.expect("error", "Bad request to fetch channel subscribers.");
    await peer_data.fetch_stream_subscribers_with_retry(india.stream_id);
    assert.equal(num_attempts, 1);
    blueslip.reset();
});

test("get_subscriber_count", async () => {
    people.add_active_user(fred);
    people.add_active_user(gail);
    people.add_active_user(george);
    const welcome_bot = make_cross_realm_bot({
        email: "[email protected]",
        user_id: 40,
        full_name: "Welcome Bot",
    });
    people.add_active_user(welcome_bot);

    const india = make_stream({
        stream_id: 102,
        name: "India",
        subscribed: true,
        subscriber_count: 0,
    });
    stream_data.clear_subscriptions();

    blueslip.expect("warn", "We called get_subscriber_count for an untracked stream: 102");
    assert.equal(peer_data.get_subscriber_count(india.stream_id), 0);
    blueslip.reset();

    stream_data.add_sub_for_tests(india);
    assert.equal(peer_data.get_subscriber_count(india.stream_id), 0);

    peer_data.add_subscriber(india.stream_id, fred.user_id);
    assert.equal(peer_data.get_subscriber_count(india.stream_id), 1);
    peer_data.add_subscriber(india.stream_id, george.user_id);
    assert.equal(peer_data.get_subscriber_count(india.stream_id), 2);

    peer_data.remove_subscriber(india.stream_id, george.user_id);
    assert.deepStrictEqual(peer_data.get_subscriber_count(india.stream_id), 1);

    peer_data.add_subscriber(india.stream_id, welcome_bot.user_id);
    assert.deepStrictEqual(peer_data.get_subscriber_count(india.stream_id), 2);
    // Get the count without bots
    assert.deepStrictEqual(peer_data.get_subscriber_count(india.stream_id, false), 1);

    // We don't have full data, so we assume this is a decrement even though gail isn't
    // in the subscriber list.
    peer_data.set_subscriber_count(india.stream_id, 20);
    assert.deepStrictEqual(peer_data.get_subscriber_count(india.stream_id), 20);
    peer_data.remove_subscriber(india.stream_id, gail.user_id);
    assert.deepStrictEqual(peer_data.get_subscriber_count(india.stream_id), 19);

    // Now fetch the actual subscribers
    mock_channel_get(channel, (opts) => {
        opts.success({
            subscribers: [george.user_id, fred.user_id],
        });
    });
    await peer_data.fetch_stream_subscribers(india.stream_id);
    assert.deepStrictEqual(peer_data.get_subscriber_count(india.stream_id), 2);
    // Now we know Gail isn't subscribed, so we don't decrement the count
    peer_data.remove_subscriber(india.stream_id, gail.user_id);
    assert.deepStrictEqual(peer_data.get_subscriber_count(india.stream_id), 2);
});

test("is_subscriber_subset", async () => {
    function make_sub(stream_id, user_ids) {
        const sub = make_stream({
            stream_id,
            name: `stream ${stream_id}`,
        });
        stream_data.add_sub_for_tests(sub);
        peer_data.set_subscribers(sub.stream_id, user_ids);
        return sub;
    }

    const sub_a = make_sub(301, [1, 2]);
    const sub_b = make_sub(302, [2, 3]);
    const sub_c = make_sub(303, [1, 2, 3]);

    const matrix = [
        [sub_a, sub_a, true],
        [sub_a, sub_b, false],
        [sub_a, sub_c, true],
        [sub_b, sub_a, false],
        [sub_b, sub_b, true],
        [sub_b, sub_c, true],
        [sub_c, sub_a, false],
        [sub_c, sub_b, false],
        [sub_c, sub_c, true],
    ];

    for (const row of matrix) {
        assert.equal(
            await peer_data.is_subscriber_subset(row[0].stream_id, row[1].stream_id),
            row[2],
        );
    }

    // Create a mock Incoming Webhook bot
    const webhook_bot = make_bot({
        email: "[email protected]",
        full_name: "Webhook Bot",
        user_id: 105,
        bot_type: INCOMING_WEBHOOK_BOT_TYPE_INT,
    });
    people.add_active_user(webhook_bot);

    // Create a mock Generic Bot
    const generic_bot = make_bot({
        email: "[email protected]",
        full_name: "Generic Bot",
        user_id: 106,
        bot_type: GENERIC_BOT_TYPE_INT,
    });
    people.add_active_user(generic_bot);

    const sub_with_webhook = make_sub(304, [1, 2, webhook_bot.user_id]);
    const sub_with_generic = make_sub(305, [1, 2, generic_bot.user_id]);
    const sub_with_unknown_user = make_sub(306, [1, 2, 9999]);

    // Webhooks should be ignored.
    assert.equal(
        await peer_data.is_subscriber_subset(sub_with_webhook.stream_id, sub_a.stream_id),
        true,
    );

    // Generic bots can read, so they are NOT ignored.
    assert.equal(
        await peer_data.is_subscriber_subset(sub_with_generic.stream_id, sub_a.stream_id),
        false,
    );

    // Unknown users are treated conservatively (not ignored).
    assert.equal(
        await peer_data.is_subscriber_subset(sub_with_unknown_user.stream_id, sub_a.stream_id),
        false,
    );

    // Two untracked streams should never be passed into us.
    blueslip.expect(
        "warn",
        "We called get_loaded_subscriber_subset for an untracked stream: 88888",
    );
    blueslip.expect(
        "warn",
        "We called get_loaded_subscriber_subset for an untracked stream: 99999",
    );
    await peer_data.is_subscriber_subset(99999, 88888);
    blueslip.reset();

    // Warn about hypothetical undefined stream_ids.
    blueslip.expect(
        "warn",
        "We called get_loaded_subscriber_subset for an untracked stream: undefined",
    );
    await peer_data.is_subscriber_subset(undefined, sub_a.stream_id);
    blueslip.reset();

    // Errors when fetching subscriber data return `null`
    mock_channel_get(channel, (opts) => {
        opts.error({status: 500});
    });
    peer_data.clear_for_testing();
    // Expect two calls, one for each channel
    blueslip.expect("error", "Failure fetching channel subscribers", 2);
    assert.equal(await peer_data.is_subscriber_subset(sub_a.stream_id, sub_b.stream_id), null);
});

test("get_unique_subscriber_count_for_streams", async () => {
    const sub = make_stream({
        name: "Rome",
        subscribed: true,
        stream_id: 1001,
    });
    stream_data.add_sub_for_tests(sub);

    people.add_active_user(fred);
    people.add_active_user(gail);
    people.add_active_user(george);
    people.add_active_user(bot_botson);

    const stream_id = sub.stream_id;
    peer_data.set_subscribers(stream_id, [me.user_id, fred.user_id, bot_botson.user_id]);

    const count = await peer_data.get_unique_subscriber_count_for_streams([stream_id]);

    assert.equal(count, 2);

    // If we only have partial data and the fetch fails, count what we have.
    peer_data.clear_for_testing();
    peer_data.set_subscribers(stream_id, [me.user_id, fred.user_id, bot_botson.user_id], false);
    mock_channel_get(channel, (opts) => {
        opts.error({status: 400, responseJSON: ""});
    });
    blueslip.expect("error", "Bad request to fetch channel subscribers.");
    assert.equal(await peer_data.get_unique_subscriber_count_for_streams([stream_id]), 2);
    blueslip.reset();
});

test("fetch_subscriptions_for_user", async () => {
    people.add_active_user(fred);

    const india = make_stream({
        stream_id: 102,
        name: "India",
        subscribed: true,
    });
    stream_data.add_sub_for_tests(india);
    const rome = make_stream({
        name: "Rome",
        subscribed: true,
        stream_id: 1001,
    });
    stream_data.add_sub_for_tests(rome);

    let channel_get_calls = 0;
    mock_channel_get(channel, (opts) => {
        assert.equal(opts.url, `/json/users/${fred.user_id}/channels`);
        channel_get_calls += 1;
        return opts.success({
            subscribed_channel_ids: [india.stream_id],
        });
    });

    // Only one of these will do the fetch, and the other will wait
    // for the first fetch to complete.
    const promise1 = peer_data.fetch_subscriptions_for_user(fred.user_id);
    const promise2 = peer_data.fetch_subscriptions_for_user(fred.user_id);
    await promise1;
    await promise2;
    assert.equal(channel_get_calls, 1);

    peer_data.clear_for_testing();
    mock_channel_get(channel, (opts) => {
        opts.error({status: 500});
    });
    blueslip.expect("warn", "Failure fetching user's subscribed channels. Retrying.", 4);
    blueslip.expect("error", "Failure fetching user's subscribed channels. Giving up.");
    await peer_data.fetch_subscriptions_for_user(fred.user_id);
    blueslip.reset();

    // After giving up, a later call should start a new fetch instead
    // of returning the finished request's promise.
    channel_get_calls = 0;
    mock_channel_get(channel, (opts) => {
        channel_get_calls += 1;
        opts.success({
            subscribed_channel_ids: [india.stream_id],
        });
    });
    await peer_data.fetch_subscriptions_for_user(fred.user_id);
    assert.equal(channel_get_calls, 1);
    assert.ok(stream_data.is_user_loaded_and_subscribed(india.stream_id, fred.user_id));

    peer_data.clear_for_testing();
    mock_channel_get(channel, (opts) => {
        opts.error({status: 400, responseJSON: {msg: "bad request"}});
    });
    blueslip.expect("error", "Bad request to fetch user's subscribed channels.");
    await peer_data.fetch_subscriptions_for_user(fred.user_id);
    blueslip.reset();

    peer_data.clear_for_testing();
    assert.ok(!stream_data.is_user_loaded_and_subscribed(india.stream_id, fred.user_id));
    let error_counter = 0;
    mock_channel_get(channel, (opts) => {
        if (error_counter === 3) {
            opts.success({
                subscribed_channel_ids: [india.stream_id],
            });
        } else {
            error_counter += 1;
            opts.error({
                status: 500,
            });
        }
    });
    blueslip.expect("warn", "Failure fetching user's subscribed channels. Retrying.", 3);
    await peer_data.fetch_subscriptions_for_user(fred.user_id);
    assert.ok(stream_data.is_user_loaded_and_subscribed(india.stream_id, fred.user_id));
    blueslip.reset();

    channel_get_calls = 0;
    mock_channel_get(channel, (opts) => {
        channel_get_calls += 1;
        opts.success({
            subscribers: [fred.user_id],
        });
    });
    await peer_data.fetch_stream_subscribers(india.stream_id);
    await peer_data.fetch_stream_subscribers(rome.stream_id);
    assert.equal(channel_get_calls, 2);

    // No get request here because we already have full subscriber data
    // for both streams.
    channel_get_calls = 0;
    await peer_data.fetch_subscriptions_for_user(fred.user_id);
    assert.equal(channel_get_calls, 0);
});

test("fetch_subscriptions_for_user stale response", async () => {
    people.add_active_user(fred);

    const social = make_stream({
        stream_id: 2,
        name: "social",
        subscribed: true,
    });
    stream_data.add_sub_for_tests(social);
    const rome = make_stream({
        name: "Rome",
        subscribed: true,
        stream_id: 1001,
    });
    stream_data.add_sub_for_tests(rome);
    const devel = make_stream({
        name: "devel",
        subscribed: true,
        stream_id: 1,
    });
    stream_data.add_sub_for_tests(devel);
    const paris = make_stream({
        name: "Paris",
        subscribed: true,
        stream_id: 1002,
    });
    stream_data.add_sub_for_tests(paris);

    peer_data.set_subscribers(social.stream_id, [fred.user_id], false);
    peer_data.set_subscribers(rome.stream_id, [fred.user_id], false);
    peer_data.set_subscribers(devel.stream_id, [fred.user_id], false);
    peer_data.set_subscribers(paris.stream_id, [fred.user_id], false);

    // The server computed this response before the removals below.
    mock_channel_get(channel, (opts) => {
        opts.success({
            subscribed_channel_ids: [
                social.stream_id,
                rome.stream_id,
                devel.stream_id,
                paris.stream_id,
            ],
        });
    });

    // The mocked response is only delivered once we await the promise,
    // so the removals below arrive while the request is in flight.
    const promise = peer_data.fetch_subscriptions_for_user(fred.user_id);
    peer_data.bulk_remove_subscribers({
        stream_ids: [social.stream_id],
        user_ids: [fred.user_id],
    });
    peer_data.remove_subscriber(devel.stream_id, fred.user_id);
    // While the request is in flight, we get the exact subscriber set
    // for Paris, which no longer includes fred.
    peer_data.set_subscribers(paris.stream_id, [me.user_id]);
    assert.ok(!peer_data.subscriber_data_loaded_for_user(fred.user_id));
    await promise;

    // The stale response must not re-add fred to social, devel, or Paris.
    assert.ok(!stream_data.is_user_loaded_and_subscribed(social.stream_id, fred.user_id));
    assert.ok(!stream_data.is_user_loaded_and_subscribed(devel.stream_id, fred.user_id));
    assert.ok(!stream_data.is_user_loaded_and_subscribed(paris.stream_id, fred.user_id));
    assert.ok(stream_data.is_user_loaded_and_subscribed(rome.stream_id, fred.user_id));
    assert.ok(peer_data.subscriber_data_loaded_for_user(fred.user_id));
});

test("fetch_subscriptions_for_user removal before retry", async () => {
    people.add_active_user(fred);

    const social = make_stream({
        stream_id: 2,
        name: "social",
        subscribed: true,
    });
    stream_data.add_sub_for_tests(social);
    peer_data.set_subscribers(social.stream_id, [fred.user_id], false);

    let num_attempts = 0;
    mock_channel_get(channel, (opts) => {
        num_attempts += 1;
        if (num_attempts === 1) {
            // fred leaves social while the first attempt is in flight,
            // and then that attempt fails.
            peer_data.remove_subscriber(social.stream_id, fred.user_id);
            opts.error({status: 500});
            return;
        }
        // fred rejoined social before the retry, so the retry's
        // response lists social and must be applied.
        opts.success({
            subscribed_channel_ids: [social.stream_id],
        });
    });
    blueslip.expect("warn", "Failure fetching user's subscribed channels. Retrying.");
    await peer_data.fetch_subscriptions_for_user(fred.user_id);
    assert.equal(num_attempts, 2);
    assert.ok(stream_data.is_user_loaded_and_subscribed(social.stream_id, fred.user_id));
});