zulip/frontend_tests/node_tests/stream_data.js

set_global('page_params', {
    is_admin: false,
    realm_users: [],
    is_guest: false,
});

set_global('$', function () {
});

set_global('document', null);
global.stub_out_jquery();

zrequire('color_data');
zrequire('hash_util');
zrequire('stream_topic_history');
zrequire('people');
zrequire('stream_color');
zrequire('stream_data');
zrequire('marked', 'third/marked/lib/marked');
zrequire('FetchStatus', 'js/fetch_status');
zrequire('Filter', 'js/filter');
zrequire('MessageListData', 'js/message_list_data');
zrequire('MessageListView', 'js/message_list_view');
zrequire('message_list');
const settings_config = zrequire("settings_config");

const me = {
    email: 'me@zulip.com',
    full_name: 'Current User',
    user_id: 100,
};

// set up user data
people.add(me);
people.initialize_current_user(me.user_id);

function contains_sub(subs, sub) {
    return subs.some(s => s.name === sub.name);
}

run_test('basics', () => {
    const denmark = {
        subscribed: false,
        color: 'blue',
        name: 'Denmark',
        stream_id: 1,
        is_muted: true,
    };
    const social = {
        subscribed: true,
        color: 'red',
        name: 'social',
        stream_id: 2,
        is_muted: false,
        invite_only: true,
        stream_post_policy: stream_data.stream_post_policy_values.admins.code,
    };
    const test = {
        subscribed: true,
        color: 'yellow',
        name: 'test',
        stream_id: 3,
        is_muted: true,
        invite_only: false,
    };
    stream_data.add_sub(denmark);
    stream_data.add_sub(social);
    assert(stream_data.all_subscribed_streams_are_in_home_view());
    stream_data.add_sub(test);
    assert(!stream_data.all_subscribed_streams_are_in_home_view());

    assert.equal(stream_data.get_sub('denmark'), denmark);
    assert.equal(stream_data.get_sub('Social'), social);

    assert.deepEqual(stream_data.home_view_stream_names(), ['social']);
    assert.deepEqual(stream_data.subscribed_streams(), ['social', 'test']);
    assert.deepEqual(stream_data.get_colors(), ['red', 'yellow']);

    assert(stream_data.is_subscribed('social'));
    assert(stream_data.is_subscribed('Social'));
    assert(!stream_data.is_subscribed('Denmark'));
    assert(!stream_data.is_subscribed('Rome'));

    assert(stream_data.get_invite_only('social'));
    assert(!stream_data.get_invite_only('unknown'));
    assert(stream_data.get_stream_post_policy('social'));
    assert(!stream_data.get_stream_post_policy('unknown'));

    assert.equal(stream_data.get_color('social'), 'red');
    assert.equal(stream_data.get_color('unknown'), global.stream_color.default_color);

    assert.equal(stream_data.get_name('denMARK'), 'Denmark');
    assert.equal(stream_data.get_name('unknown Stream'), 'unknown Stream');

    assert(!stream_data.is_muted(social.stream_id));
    assert(stream_data.is_muted(denmark.stream_id));

    assert.equal(stream_data.maybe_get_stream_name(), undefined);
    assert.equal(stream_data.maybe_get_stream_name(social.stream_id), 'social');
    assert.equal(stream_data.maybe_get_stream_name(42), undefined);

    stream_data.set_realm_default_streams([denmark]);
    assert(stream_data.is_default_stream_id(denmark.stream_id));
    assert(!stream_data.is_default_stream_id(social.stream_id));
    assert(!stream_data.is_default_stream_id(999999));
});

run_test('renames', () => {
    stream_data.clear_subscriptions();
    const id = 42;
    let sub = {
        name: 'Denmark',
        subscribed: true,
        color: 'red',
        stream_id: id,
    };
    stream_data.add_sub(sub);
    sub = stream_data.get_sub('Denmark');
    assert.equal(sub.color, 'red');
    sub = stream_data.get_sub_by_id(id);
    assert.equal(sub.color, 'red');

    stream_data.rename_sub(sub, 'Sweden');
    sub = stream_data.get_sub_by_id(id);
    assert.equal(sub.color, 'red');
    assert.equal(sub.name, 'Sweden');

    sub = stream_data.get_sub('Denmark');
    assert.equal(sub, undefined);

    sub = stream_data.get_sub_by_name('Denmark');
    assert.equal(sub.name, 'Sweden');

    const actual_id = stream_data.get_stream_id('Denmark');
    assert.equal(actual_id, 42);
});

run_test('unsubscribe', () => {
    stream_data.clear_subscriptions();

    let sub = {name: 'devel', subscribed: false, stream_id: 1};

    // set up our subscription
    stream_data.add_sub(sub);
    sub.subscribed = true;
    stream_data.set_subscribers(sub, [me.user_id]);

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

    // DO THE UNSUBSCRIBE HERE
    stream_data.unsubscribe_myself(sub);
    assert(!sub.subscribed);
    assert(!stream_data.is_subscribed('devel'));
    assert(!contains_sub(stream_data.subscribed_subs(), sub));
    assert(contains_sub(stream_data.unsubscribed_subs(), sub));

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

run_test('subscribers', () => {
    stream_data.clear_subscriptions();
    let sub = {name: 'Rome', subscribed: true, stream_id: 1};

    stream_data.add_sub(sub);

    const fred = {
        email: 'fred@zulip.com',
        full_name: 'Fred',
        user_id: 101,
    };
    const not_fred = {
        email: 'not_fred@zulip.com',
        full_name: 'Not Fred',
        user_id: 102,
    };
    const george = {
        email: 'george@zulip.com',
        full_name: 'George',
        user_id: 103,
    };
    people.add(fred);
    people.add(not_fred);
    people.add(george);

    function potential_subscriber_ids() {
        const users = stream_data.potential_subscribers(sub);
        return users.map((u) => u.user_id).sort();
    }

    assert.deepEqual(
        potential_subscriber_ids(),
        [
            me.user_id,
            fred.user_id,
            not_fred.user_id,
            george.user_id,
        ]
    );

    stream_data.set_subscribers(sub, [me.user_id, fred.user_id, george.user_id]);
    stream_data.update_calculated_fields(sub);
    assert(stream_data.is_user_subscribed('Rome', me.user_id));
    assert(stream_data.is_user_subscribed('Rome', fred.user_id));
    assert(stream_data.is_user_subscribed('Rome', george.user_id));
    assert(!stream_data.is_user_subscribed('Rome', not_fred.user_id));

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

    stream_data.set_subscribers(sub, []);

    const brutus = {
        email: 'brutus@zulip.com',
        full_name: 'Brutus',
        user_id: 104,
    };
    people.add(brutus);
    assert(!stream_data.is_user_subscribed('Rome', brutus.user_id));

    // add
    let ok = stream_data.add_subscriber('Rome', brutus.user_id);
    assert(ok);
    assert(stream_data.is_user_subscribed('Rome', brutus.user_id));
    sub = stream_data.get_sub('Rome');
    stream_data.update_subscribers_count(sub);
    assert.equal(sub.subscriber_count, 1);
    const sub_email = "Rome:214125235@zulipdev.com:9991";
    stream_data.update_stream_email_address(sub, sub_email);
    assert.equal(sub.email_address, sub_email);

    // verify that adding an already-added subscriber is a noop
    stream_data.add_subscriber('Rome', brutus.user_id);
    assert(stream_data.is_user_subscribed('Rome', brutus.user_id));
    sub = stream_data.get_sub('Rome');
    stream_data.update_subscribers_count(sub);
    assert.equal(sub.subscriber_count, 1);

    // remove
    ok = stream_data.remove_subscriber('Rome', brutus.user_id);
    assert(ok);
    assert(!stream_data.is_user_subscribed('Rome', brutus.user_id));
    sub = stream_data.get_sub('Rome');
    stream_data.update_subscribers_count(sub);
    assert.equal(sub.subscriber_count, 0);

    // verify that checking subscription with undefined user id

    blueslip.expect('warn', 'Undefined user_id passed to function is_user_subscribed');
    assert.equal(stream_data.is_user_subscribed('Rome', undefined), undefined);

    // Verify noop for bad stream when removing subscriber
    const bad_stream = 'UNKNOWN';
    blueslip.expect('warn', 'We got a remove_subscriber call for a non-existent stream ' + bad_stream);
    ok = stream_data.remove_subscriber(bad_stream, brutus.user_id);
    assert(!ok);
    assert.equal(blueslip.get_test_logs('warn').length, 2);

    // verify that removing an already-removed subscriber is a noop
    blueslip.expect('warn', 'We tried to remove invalid subscriber: 104');
    ok = stream_data.remove_subscriber('Rome', brutus.user_id);
    assert(!ok);
    assert(!stream_data.is_user_subscribed('Rome', brutus.user_id));
    sub = stream_data.get_sub('Rome');
    stream_data.update_subscribers_count(sub);
    assert.equal(sub.subscriber_count, 0);

    // Verify defensive code in set_subscribers, where the second parameter
    // can be undefined.
    stream_data.set_subscribers(sub);
    stream_data.add_sub(sub);
    stream_data.add_subscriber('Rome', brutus.user_id);
    sub.subscribed = true;
    assert(stream_data.is_user_subscribed('Rome', brutus.user_id));

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

    blueslip.expect(
        'warn',
        'We got a is_user_subscribed call for a non-existent or inaccessible stream.');
    sub.invite_only = true;
    stream_data.update_calculated_fields(sub);
    assert.equal(stream_data.is_user_subscribed('Rome', brutus.user_id), undefined);
    stream_data.remove_subscriber('Rome', brutus.user_id);
    assert.equal(stream_data.is_user_subscribed('Rome', brutus.user_id), undefined);

    // Verify that we don't crash and return false for a bad stream.
    blueslip.expect(
        'warn',
        'We got an add_subscriber call for a non-existent stream.');
    ok = stream_data.add_subscriber('UNKNOWN', brutus.user_id);
    assert(!ok);

    // Verify that we don't crash and return false for a bad user id.
    blueslip.expect('error', 'Unknown user_id in get_by_user_id: 9999999');
    blueslip.expect('error', 'We tried to add invalid subscriber: 9999999');
    ok = stream_data.add_subscriber('Rome', 9999999);
    assert(!ok);
    assert.equal(blueslip.get_test_logs('error').length, 2);
    blueslip.reset();
});

run_test('is_active', () => {
    stream_data.clear_subscriptions();

    let sub;

    page_params.demote_inactive_streams =
        settings_config.demote_inactive_streams_values.automatic.code;
    stream_data.set_filter_out_inactives();

    sub = {name: 'pets', subscribed: false, stream_id: 111};
    stream_data.add_sub(sub);

    assert(stream_data.is_active(sub));

    stream_data.subscribe_myself(sub);
    assert(stream_data.is_active(sub));

    assert(contains_sub(stream_data.subscribed_subs(), sub));
    assert(!contains_sub(stream_data.unsubscribed_subs(), sub));

    stream_data.unsubscribe_myself(sub);
    assert(stream_data.is_active(sub));

    sub.pin_to_top = true;
    assert(stream_data.is_active(sub));
    sub.pin_to_top = false;

    const opts = {
        stream_id: 222,
        message_id: 108,
        topic_name: 'topic2',
    };
    stream_topic_history.add_message(opts);

    assert(stream_data.is_active(sub));

    page_params.demote_inactive_streams =
        settings_config.demote_inactive_streams_values.always.code;
    stream_data.set_filter_out_inactives();

    sub = {name: 'pets', subscribed: false, stream_id: 111};
    stream_data.add_sub(sub);

    assert(!stream_data.is_active(sub));

    sub.pin_to_top = true;
    assert(stream_data.is_active(sub));
    sub.pin_to_top = false;

    stream_data.subscribe_myself(sub);
    assert(stream_data.is_active(sub));

    stream_data.unsubscribe_myself(sub);
    assert(!stream_data.is_active(sub));

    sub = {name: 'lunch', subscribed: false, stream_id: 222};
    stream_data.add_sub(sub);

    assert(stream_data.is_active(sub));

    stream_topic_history.add_message(opts);

    assert(stream_data.is_active(sub));

    page_params.demote_inactive_streams =
        settings_config.demote_inactive_streams_values.never.code;
    stream_data.set_filter_out_inactives();

    sub = {name: 'pets', subscribed: false, stream_id: 111};
    stream_data.add_sub(sub);

    assert(stream_data.is_active(sub));

    stream_data.subscribe_myself(sub);
    assert(stream_data.is_active(sub));

    stream_data.unsubscribe_myself(sub);
    assert(stream_data.is_active(sub));

    sub.pin_to_top = true;
    assert(stream_data.is_active(sub));

    stream_topic_history.add_message(opts);

    assert(stream_data.is_active(sub));
});

run_test('admin_options', () => {
    function make_sub() {
        const sub = {
            subscribed: false,
            color: 'blue',
            name: 'stream_to_admin',
            stream_id: 1,
            is_muted: true,
            invite_only: false,
        };
        stream_data.add_sub(sub);
        return sub;
    }

    // non-admins can't do anything
    global.page_params.is_admin = false;
    let sub = make_sub();
    stream_data.update_calculated_fields(sub);
    assert(!sub.is_admin);
    assert(!sub.can_change_stream_permissions);

    // just a sanity check that we leave "normal" fields alone
    assert.equal(sub.color, 'blue');

    // the remaining cases are for admin users
    global.page_params.is_admin = true;

    // admins can make public streams become private
    sub = make_sub();
    stream_data.update_calculated_fields(sub);
    assert(sub.is_admin);
    assert(sub.can_change_stream_permissions);

    // admins can only make private streams become public
    // if they are subscribed
    sub = make_sub();
    sub.invite_only = true;
    sub.subscribed = false;
    stream_data.update_calculated_fields(sub);
    assert(sub.is_admin);
    assert(!sub.can_change_stream_permissions);

    sub = make_sub();
    sub.invite_only = true;
    sub.subscribed = true;
    stream_data.update_calculated_fields(sub);
    assert(sub.is_admin);
    assert(sub.can_change_stream_permissions);
});

run_test('stream_settings', () => {
    const cinnamon = {
        stream_id: 1,
        name: 'c',
        color: 'cinnamon',
        subscribed: true,
        invite_only: false,
    };

    const blue = {
        stream_id: 2,
        name: 'b',
        color: 'blue',
        subscribed: false,
        invite_only: false,
    };

    const amber = {
        stream_id: 3,
        name: 'a',
        color: 'amber',
        subscribed: true,
        invite_only: true,
        history_public_to_subscribers: true,
        stream_post_policy: stream_data.stream_post_policy_values.admins.code,
    };
    stream_data.clear_subscriptions();
    stream_data.add_sub(cinnamon);
    stream_data.add_sub(amber);
    stream_data.add_sub(blue);

    let sub_rows = stream_data.get_streams_for_settings_page();
    assert.equal(sub_rows[0].color, 'blue');
    assert.equal(sub_rows[1].color, 'amber');
    assert.equal(sub_rows[2].color, 'cinnamon');

    sub_rows = stream_data.get_streams_for_admin();
    assert.equal(sub_rows[0].name, 'a');
    assert.equal(sub_rows[1].name, 'b');
    assert.equal(sub_rows[2].name, 'c');
    assert.equal(sub_rows[0].invite_only, true);
    assert.equal(sub_rows[1].invite_only, false);
    assert.equal(sub_rows[2].invite_only, false);

    assert.equal(sub_rows[0].history_public_to_subscribers, true);
    assert.equal(sub_rows[0].stream_post_policy ===
        stream_data.stream_post_policy_values.admins.code, true);

    const sub = stream_data.get_sub('a');
    stream_data.update_stream_privacy(sub, {
        invite_only: false,
        history_public_to_subscribers: false,
    });
    stream_data.update_stream_post_policy(sub, 1);
    stream_data.update_calculated_fields(sub);
    assert.equal(sub.invite_only, false);
    assert.equal(sub.history_public_to_subscribers, false);
    assert.equal(sub.stream_post_policy,
                 stream_data.stream_post_policy_values.everyone.code);

    // For guest user only retrieve subscribed streams
    sub_rows = stream_data.get_updated_unsorted_subs();
    assert.equal(sub_rows.length, 3);
    global.page_params.is_guest = true;
    sub_rows = stream_data.get_updated_unsorted_subs();
    assert.equal(sub_rows[0].name, 'c');
    assert.equal(sub_rows[1].name, 'a');
    assert.equal(sub_rows.length, 2);
});

run_test('default_stream_names', () => {
    const announce = {
        stream_id: 101,
        name: 'announce',
        subscribed: true,
    };

    const public_stream = {
        stream_id: 102,
        name: 'public',
        subscribed: true,
    };

    const private_stream = {
        stream_id: 103,
        name: 'private',
        subscribed: true,
        invite_only: true,
    };

    const general = {
        stream_id: 104,
        name: 'general',
        subscribed: true,
        invite_only: false,
    };

    stream_data.clear_subscriptions();
    stream_data.set_realm_default_streams([announce, general]);
    stream_data.add_sub(announce);
    stream_data.add_sub(public_stream);
    stream_data.add_sub(private_stream);
    stream_data.add_sub(general);

    const names = stream_data.get_non_default_stream_names();
    assert.deepEqual(names.sort(), ['private', 'public']);

    const default_stream_ids = stream_data.get_default_stream_ids();
    assert.deepEqual(
        default_stream_ids.sort(),
        [
            announce.stream_id,
            general.stream_id,
        ]
    );
});

run_test('delete_sub', () => {
    const canada = {
        stream_id: 101,
        name: 'Canada',
        subscribed: true,
    };

    stream_data.clear_subscriptions();
    stream_data.add_sub(canada);

    assert(stream_data.is_subscribed('Canada'));
    assert(stream_data.get_sub('Canada').stream_id, canada.stream_id);
    assert(stream_data.get_sub_by_id(canada.stream_id).name, 'Canada');

    stream_data.delete_sub(canada.stream_id);
    assert(!stream_data.is_subscribed('Canada'));
    assert(!stream_data.get_sub('Canada'));
    assert(!stream_data.get_sub_by_id(canada.stream_id));

    blueslip.expect('warn', 'Failed to delete stream 99999');
    stream_data.delete_sub(99999);
    blueslip.reset();
});

run_test('get_subscriber_count', () => {
    const india = {
        stream_id: 102,
        name: 'India',
        subscribed: true,
    };
    stream_data.clear_subscriptions();

    blueslip.expect('warn', 'We got a get_subscriber_count count call for a non-existent stream.');
    assert.equal(stream_data.get_subscriber_count('India'), undefined);
    blueslip.reset();

    stream_data.add_sub(india);
    assert.equal(stream_data.get_subscriber_count('India'), 0);

    const fred = {
        email: 'fred@zulip.com',
        full_name: 'Fred',
        user_id: 101,
    };
    people.add(fred);
    stream_data.add_subscriber('India', 102);
    assert.equal(stream_data.get_subscriber_count('India'), 1);
    const george = {
        email: 'george@zulip.com',
        full_name: 'George',
        user_id: 103,
    };
    people.add(george);
    stream_data.add_subscriber('India', 103);
    assert.equal(stream_data.get_subscriber_count('India'), 2);

    const sub = stream_data.get_sub_by_name('India');
    delete sub.subscribers;
    assert.deepStrictEqual(stream_data.get_subscriber_count('India'), 0);
});

run_test('notifications', () => {
    const india = {
        stream_id: 102,
        name: 'India',
        subscribed: true,
        invite_only: false,
        is_web_public: false,
        desktop_notifications: null,
        audible_notifications: null,
        email_notifications: null,
        push_notifications: null,
        wildcard_mentions_notify: null,
    };
    stream_data.clear_subscriptions();
    stream_data.add_sub(india);

    assert(!stream_data.receives_notifications('Indiana', "desktop_notifications"));
    assert(!stream_data.receives_notifications('Indiana', "audible_notifications"));

    page_params.enable_stream_desktop_notifications = true;
    page_params.enable_stream_audible_notifications = true;
    assert(stream_data.receives_notifications('India', "desktop_notifications"));
    assert(stream_data.receives_notifications('India', "audible_notifications"));

    page_params.enable_stream_desktop_notifications = false;
    page_params.enable_stream_audible_notifications = false;
    assert(!stream_data.receives_notifications('India', "desktop_notifications"));
    assert(!stream_data.receives_notifications('India', "audible_notifications"));

    india.desktop_notifications = true;
    india.audible_notifications = true;
    assert(stream_data.receives_notifications('India', "desktop_notifications"));
    assert(stream_data.receives_notifications('India', "audible_notifications"));

    india.desktop_notifications = false;
    india.audible_notifications = false;
    page_params.enable_stream_desktop_notifications = true;
    page_params.enable_stream_audible_notifications = true;
    assert(!stream_data.receives_notifications('India', "desktop_notifications"));
    assert(!stream_data.receives_notifications('India', "audible_notifications"));

    page_params.wildcard_mentions_notify = true;
    assert(stream_data.receives_notifications('India', "wildcard_mentions_notify"));
    page_params.wildcard_mentions_notify = false;
    assert(!stream_data.receives_notifications('India', "wildcard_mentions_notify"));
    india.wildcard_mentions_notify = true;
    assert(stream_data.receives_notifications('India', "wildcard_mentions_notify"));
    page_params.wildcard_mentions_notify = true;
    india.wildcard_mentions_notify = false;
    assert(!stream_data.receives_notifications('India', "wildcard_mentions_notify"));

    page_params.enable_stream_push_notifications = true;
    assert(stream_data.receives_notifications('India', "push_notifications"));
    page_params.enable_stream_push_notifications = false;
    assert(!stream_data.receives_notifications('India', "push_notifications"));
    india.push_notifications = true;
    assert(stream_data.receives_notifications('India', "push_notifications"));
    page_params.enable_stream_push_notifications = true;
    india.push_notifications = false;
    assert(!stream_data.receives_notifications('India', "push_notifications"));

    page_params.enable_stream_email_notifications = true;
    assert(stream_data.receives_notifications('India', "email_notifications"));
    page_params.enable_stream_email_notifications = false;
    assert(!stream_data.receives_notifications('India', "email_notifications"));
    india.email_notifications = true;
    assert(stream_data.receives_notifications('India', "email_notifications"));
    page_params.enable_stream_email_notifications = true;
    india.email_notifications = false;
    assert(!stream_data.receives_notifications('India', "email_notifications"));

    const canada = {
        stream_id: 103,
        name: 'Canada',
        subscribed: true,
        invite_only: true,
        is_web_public: false,
        desktop_notifications: null,
        audible_notifications: null,
        email_notifications: null,
        push_notifications: null,
        wildcard_mentions_notify: null,
    };
    stream_data.add_sub(canada);

    const antarctica = {
        stream_id: 104,
        name: 'Antarctica',
        subscribed: true,
        desktop_notifications: null,
        audible_notifications: null,
        email_notifications: null,
        push_notifications: null,
        wildcard_mentions_notify: null,
    };
    stream_data.add_sub(antarctica);

    page_params.enable_stream_desktop_notifications = true;
    page_params.enable_stream_audible_notifications = true;
    page_params.enable_stream_email_notifications = false;
    page_params.enable_stream_push_notifications = false;
    page_params.wildcard_mentions_notify = true;

    india.desktop_notifications = null;
    india.audible_notifications = true;
    india.email_notifications = true;
    india.push_notifications = true;
    india.wildcard_mentions_notify = false;

    canada.desktop_notifications = true;
    canada.audible_notifications = false;
    canada.email_notifications = true;
    canada.push_notifications = null;
    canada.wildcard_mentions_notify = false;

    antarctica.desktop_notifications = true;
    antarctica.audible_notifications = null;
    antarctica.email_notifications = false;
    antarctica.push_notifications = null;
    antarctica.wildcard_mentions_notify = null;

    const unmatched_streams = stream_data.get_unmatched_streams_for_notification_settings();
    const expected_streams = [
        {
            desktop_notifications: true,
            audible_notifications: false,
            email_notifications: true,
            push_notifications: false,
            wildcard_mentions_notify: false,
            invite_only: true,
            is_web_public: false,
            stream_name: 'Canada',
            stream_id: 103,
        },
        {
            desktop_notifications: true,
            audible_notifications: true,
            email_notifications: true,
            push_notifications: true,
            wildcard_mentions_notify: false,
            invite_only: false,
            is_web_public: false,
            stream_name: 'India',
            stream_id: 102,
        },
    ];

    assert.deepEqual(unmatched_streams, expected_streams);
});

run_test('is_muted', () => {
    const tony = {
        stream_id: 999,
        name: 'tony',
        subscribed: true,
        is_muted: false,
    };

    const jazy = {
        stream_id: 500,
        name: 'jazy',
        subscribed: false,
        is_muted: true,
    };

    stream_data.add_sub(tony);
    stream_data.add_sub(jazy);
    assert(!stream_data.is_stream_muted_by_name('tony'));
    assert(stream_data.is_stream_muted_by_name('jazy'));
    assert(stream_data.is_stream_muted_by_name('EEXISTS'));
});

run_test('is_notifications_stream_muted', () => {
    page_params.notifications_stream = 'tony';
    assert(!stream_data.is_notifications_stream_muted());

    page_params.notifications_stream = 'jazy';
    assert(stream_data.is_notifications_stream_muted());
});

run_test('remove_default_stream', () => {
    const remove_me = {
        stream_id: 674,
        name: 'remove_me',
        subscribed: false,
        is_muted: true,
    };

    stream_data.add_sub(remove_me);
    stream_data.set_realm_default_streams([remove_me]);
    stream_data.remove_default_stream(remove_me.stream_id);
    assert(!stream_data.is_default_stream_id(remove_me.stream_id));
});

run_test('canonicalized_name', () => {
    assert.deepStrictEqual(
        stream_data.canonicalized_name('Stream_Bar'),
        "stream_bar"
    );
});

run_test('create_sub', () => {
    stream_data.clear_subscriptions();
    const india = {
        stream_id: 102,
        name: 'India',
        subscribed: true,
    };

    const canada = {
        name: 'Canada',
        subscribed: true,
    };

    const antarctica = {
        stream_id: 103,
        name: 'Antarctica',
        subscribed: true,
        color: '#76ce90',
    };

    color_data.pick_color = function () {
        return '#bd86e5';
    };

    const india_sub = stream_data.create_sub_from_server_data('India', india);
    assert(india_sub);
    assert.equal(india_sub.color, '#bd86e5');
    const new_sub = stream_data.create_sub_from_server_data('India', india); // make sure sub doesn't get created twice
    assert.equal(india_sub, new_sub);

    assert.throws(() => {
        stream_data.create_sub_from_server_data('Canada', canada);
    }, {message: 'We cannot create a sub without a stream_id'});

    const antarctica_sub = stream_data.create_sub_from_server_data('Antarctica', antarctica);
    assert(antarctica_sub);
    assert.equal(antarctica_sub.color, '#76ce90');
});

run_test('initialize', () => {
    function get_params() {
        const params = {};

        params.subscriptions = [{
            name: 'subscriptions',
            stream_id: 2001,
        }];

        params.unsubscribed = [{
            name: 'unsubscribed',
            stream_id: 2002,
        }];

        params.never_subscribed = [{
            name: 'never_subscribed',
            stream_id: 2003,
        }];

        params.realm_default_streams = [
        ];

        return params;
    }

    function initialize() {
        stream_data.initialize(get_params());
    }

    page_params.demote_inactive_streams = 1;
    page_params.realm_notifications_stream_id = -1;

    initialize();
    assert(!stream_data.is_filtering_inactives());

    const stream_names = stream_data.get_streams_for_admin().map(elem => elem.name);
    assert(stream_names.includes('subscriptions'));
    assert(stream_names.includes('unsubscribed'));
    assert(stream_names.includes('never_subscribed'));
    assert.equal(page_params.notifications_stream, "");

    // Simulate a private stream the user isn't subscribed to
    page_params.realm_notifications_stream_id = 89;
    initialize();
    assert.equal(page_params.notifications_stream, "");

    // Now actually subscribe the user to the stream
    initialize();
    const foo = {
        name: 'foo',
        stream_id: 89,
    };

    stream_data.add_sub(foo);
    initialize();
    assert.equal(page_params.notifications_stream, "foo");
});

run_test('filter inactives', () => {
    const params = {};
    params.unsubscribed = [];
    params.never_subscribed = [];
    params.subscriptions = [];
    params.realm_default_streams = [];

    stream_data.initialize(params);
    assert(!stream_data.is_filtering_inactives());

    _.times(30, function (i) {
        const name = 'random' + i.toString();
        const stream_id = 100 + i;

        const sub = {
            name: name,
            subscribed: true,
            newly_subscribed: false,
            stream_id: stream_id,
        };
        stream_data.add_sub(sub);
    });
    stream_data.initialize(params);
    assert(stream_data.is_filtering_inactives());
});

run_test('is_subscriber_subset', () => {
    function make_sub(user_ids) {
        const sub = {};
        stream_data.set_subscribers(sub, user_ids);
        return sub;
    }

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

    // The bogus case should not come up in normal
    // use.
    // We simply punt on any calculation if
    // a stream has no subscriber info (like
    // maybe Zephyr?).
    const bogus = {}; // no subscribers

    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],
        [bogus, bogus, false],
    ];

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

run_test('edge_cases', () => {
    const bad_stream_ids = [555555, 99999];

    // just make sure we don't explode
    stream_data.sort_for_stream_settings(bad_stream_ids);
});

run_test('get_invite_stream_data', () => {
    // add default stream
    const orie = {
        name: 'Orie',
        stream_id: 320,
        invite_only: false,
        subscribed: true,
    };

    // clear all the data form stream_data, and people
    stream_data.clear_subscriptions();
    people.init();

    stream_data.add_sub(orie);
    stream_data.set_realm_default_streams([orie]);

    const expected_list = [{
        name: 'Orie',
        stream_id: 320,
        invite_only: false,
        default_stream: true,
    }];
    assert.deepEqual(stream_data.get_invite_stream_data(), expected_list);

    const inviter = {
        name: 'Inviter',
        stream_id: 25,
        invite_only: true,
        subscribed: true,
    };
    stream_data.add_sub(inviter);

    expected_list.push({
        name: 'Inviter',
        stream_id: 25,
        invite_only: true,
        default_stream: false,
    });
    assert.deepEqual(stream_data.get_invite_stream_data(), expected_list);
});

run_test('all_topics_in_cache', () => {
    // Add a new stream with first_message_id set.
    const general = {
        name: 'general',
        stream_id: 21,
        first_message_id: null,
    };
    const messages = [
        {id: 1, stream_id: 21},
        {id: 2, stream_id: 21},
        {id: 3, stream_id: 21},
    ];
    const sub = stream_data.create_sub_from_server_data('general', general);

    assert.equal(stream_data.all_topics_in_cache(sub), false);

    message_list.all.data.add_messages(messages);
    assert.equal(stream_data.all_topics_in_cache(sub), false);
    message_list.all.fetch_status.has_found_newest = () => {return true;};
    assert.equal(stream_data.all_topics_in_cache(sub), true);

    sub.first_message_id = 0;
    assert.equal(stream_data.all_topics_in_cache(sub), false);

    sub.first_message_id = 2;
    assert.equal(stream_data.all_topics_in_cache(sub), true);
});