mirror of
https://github.com/zulip/zulip.git
synced 2025-11-12 18:06:44 +00:00
42435db492
This run_test helper sets up a convention that allows us to give really short tracebacks for errors, and eventually we can have more control over running individual tests. (The latter goal has some complications, since we often intentionally leak setup in tests.)
725 lines
21 KiB
JavaScript
725 lines
21 KiB
JavaScript
set_global('page_params', {
|
|
is_admin: false,
|
|
realm_users: [],
|
|
});
|
|
|
|
set_global('$', function () {
|
|
});
|
|
|
|
set_global('blueslip', {});
|
|
|
|
zrequire('util');
|
|
zrequire('hash_util');
|
|
zrequire('narrow');
|
|
zrequire('topic_data');
|
|
zrequire('people');
|
|
zrequire('stream_color');
|
|
zrequire('stream_data');
|
|
zrequire('marked', 'third/marked/lib/marked');
|
|
|
|
run_test('basics', () => {
|
|
var denmark = {
|
|
subscribed: false,
|
|
color: 'blue',
|
|
name: 'Denmark',
|
|
stream_id: 1,
|
|
in_home_view: false,
|
|
};
|
|
var social = {
|
|
subscribed: true,
|
|
color: 'red',
|
|
name: 'social',
|
|
stream_id: 2,
|
|
in_home_view: true,
|
|
invite_only: true,
|
|
};
|
|
var test = {
|
|
subscribed: true,
|
|
color: 'yellow',
|
|
name: 'test',
|
|
stream_id: 3,
|
|
in_home_view: false,
|
|
invite_only: false,
|
|
};
|
|
stream_data.add_sub('Denmark', denmark);
|
|
stream_data.add_sub('social', social);
|
|
assert(stream_data.all_subscribed_streams_are_in_home_view());
|
|
stream_data.add_sub('test', 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.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.in_home_view(social.stream_id));
|
|
assert(!stream_data.in_home_view(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.get_default_status('Denmark'));
|
|
assert(!stream_data.get_default_status('social'));
|
|
assert(!stream_data.get_default_status('UNKNOWN'));
|
|
});
|
|
|
|
run_test('renames', () => {
|
|
stream_data.clear_subscriptions();
|
|
var id = 42;
|
|
var sub = {
|
|
name: 'Denmark',
|
|
subscribed: true,
|
|
color: 'red',
|
|
stream_id: id,
|
|
};
|
|
stream_data.add_sub('Denmark', 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');
|
|
|
|
var actual_id = stream_data.get_stream_id('Denmark');
|
|
assert.equal(actual_id, 42);
|
|
});
|
|
|
|
run_test('unsubscribe', () => {
|
|
stream_data.clear_subscriptions();
|
|
|
|
var sub = {name: 'devel', subscribed: false, stream_id: 1};
|
|
var me = {
|
|
email: 'me@zulip.com',
|
|
full_name: 'Current User',
|
|
user_id: 81,
|
|
};
|
|
|
|
// set up user data
|
|
people.add(me);
|
|
people.initialize_current_user(me.user_id);
|
|
|
|
// set up our subscription
|
|
stream_data.add_sub('devel', 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'));
|
|
|
|
// make sure subsequent calls work
|
|
sub = stream_data.get_sub('devel');
|
|
assert(!sub.subscribed);
|
|
});
|
|
|
|
run_test('subscribers', () => {
|
|
stream_data.clear_subscriptions();
|
|
var sub = {name: 'Rome', subscribed: true, stream_id: 1};
|
|
|
|
stream_data.add_sub('Rome', sub);
|
|
|
|
var fred = {
|
|
email: 'fred@zulip.com',
|
|
full_name: 'Fred',
|
|
user_id: 101,
|
|
};
|
|
var not_fred = {
|
|
email: 'not_fred@zulip.com',
|
|
full_name: 'Not Fred',
|
|
user_id: 102,
|
|
};
|
|
var george = {
|
|
email: 'george@zulip.com',
|
|
full_name: 'George',
|
|
user_id: 103,
|
|
};
|
|
people.add(fred);
|
|
people.add(not_fred);
|
|
people.add(george);
|
|
|
|
stream_data.set_subscribers(sub, [fred.user_id, george.user_id]);
|
|
stream_data.update_calculated_fields(sub);
|
|
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));
|
|
|
|
stream_data.set_subscribers(sub, []);
|
|
|
|
var 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
|
|
var 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);
|
|
var 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 deactivating user should unsubscribe user from all streams
|
|
assert(stream_data.add_subscriber('Rome', george.user_id));
|
|
set_global('subs', { rerender_subscriptions_settings: function () {} });
|
|
stream_data.remove_deactivated_user_from_all_streams(george.user_id);
|
|
assert(!stream_data.is_user_subscribed('Rome', george.user_id));
|
|
|
|
// verify that checking subscription with undefined user id
|
|
global.blueslip.warn = function (msg) {
|
|
assert.equal(msg, "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
|
|
var bad_stream = 'UNKNOWN';
|
|
global.blueslip.warn = function (msg) {
|
|
assert.equal(msg, "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);
|
|
|
|
// Defensive code will give warnings, which we ignore for the
|
|
// tests, but the defensive code needs to not actually blow up.
|
|
global.blueslip.warn = function () {};
|
|
|
|
// verify that removing an already-removed subscriber is a noop
|
|
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('Rome', 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);
|
|
|
|
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.
|
|
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.
|
|
global.blueslip.error = function () {};
|
|
ok = stream_data.add_subscriber('Rome', 9999999);
|
|
assert(!ok);
|
|
});
|
|
|
|
run_test('is_active', () => {
|
|
stream_data.clear_subscriptions();
|
|
|
|
var sub = {name: 'pets', subscribed: false, stream_id: 1};
|
|
stream_data.add_sub('pets', 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 = {name: 'lunch', subscribed: false, stream_id: 222};
|
|
stream_data.add_sub('lunch', sub);
|
|
|
|
assert(!stream_data.is_active(sub));
|
|
|
|
var opts = {
|
|
stream_id: 222,
|
|
message_id: 108,
|
|
topic_name: 'topic2',
|
|
};
|
|
topic_data.add_message(opts);
|
|
|
|
assert(stream_data.is_active(sub));
|
|
});
|
|
|
|
run_test('admin_options', () => {
|
|
function make_sub() {
|
|
var sub = {
|
|
subscribed: false,
|
|
color: 'blue',
|
|
name: 'stream_to_admin',
|
|
stream_id: 1,
|
|
in_home_view: false,
|
|
invite_only: false,
|
|
};
|
|
stream_data.add_sub(sub.name, sub);
|
|
return sub;
|
|
}
|
|
|
|
// non-admins can't do anything
|
|
global.page_params.is_admin = false;
|
|
var sub = make_sub();
|
|
stream_data.update_calculated_fields(sub);
|
|
assert(!sub.is_admin);
|
|
assert(!sub.can_make_public);
|
|
assert(!sub.can_make_private);
|
|
|
|
// 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_make_public);
|
|
assert(sub.can_make_private);
|
|
|
|
// 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_make_public);
|
|
assert(!sub.can_make_private);
|
|
|
|
sub = make_sub();
|
|
sub.invite_only = true;
|
|
sub.subscribed = true;
|
|
stream_data.update_calculated_fields(sub);
|
|
assert(sub.is_admin);
|
|
assert(sub.can_make_public);
|
|
assert(!sub.can_make_private);
|
|
});
|
|
|
|
run_test('stream_settings', () => {
|
|
var cinnamon = {
|
|
stream_id: 1,
|
|
name: 'c',
|
|
color: 'cinnamon',
|
|
subscribed: true,
|
|
invite_only: false,
|
|
};
|
|
|
|
var blue = {
|
|
stream_id: 2,
|
|
name: 'b',
|
|
color: 'blue',
|
|
subscribed: false,
|
|
invite_only: false,
|
|
};
|
|
|
|
var amber = {
|
|
stream_id: 3,
|
|
name: 'a',
|
|
color: 'amber',
|
|
subscribed: true,
|
|
invite_only: true,
|
|
};
|
|
stream_data.clear_subscriptions();
|
|
stream_data.add_sub(cinnamon.name, cinnamon);
|
|
stream_data.add_sub(amber.name, amber);
|
|
stream_data.add_sub(blue.name, blue);
|
|
|
|
var 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);
|
|
|
|
});
|
|
|
|
run_test('get_non_default_stream_names', () => {
|
|
var announce = {
|
|
stream_id: 101,
|
|
name: 'announce',
|
|
subscribed: true,
|
|
};
|
|
|
|
var public_stream = {
|
|
stream_id: 102,
|
|
name: 'public',
|
|
subscribed: true,
|
|
};
|
|
|
|
var private_stream = {
|
|
stream_id: 103,
|
|
name: 'private',
|
|
subscribed: true,
|
|
invite_only: true,
|
|
};
|
|
|
|
stream_data.clear_subscriptions();
|
|
stream_data.set_realm_default_streams([announce]);
|
|
stream_data.add_sub('announce', announce);
|
|
stream_data.add_sub('public_stream', public_stream);
|
|
stream_data.add_sub('private_stream', private_stream);
|
|
|
|
var names = stream_data.get_non_default_stream_names();
|
|
assert.deepEqual(names, ['public', 'private']);
|
|
});
|
|
|
|
run_test('delete_sub', () => {
|
|
var canada = {
|
|
stream_id: 101,
|
|
name: 'Canada',
|
|
subscribed: true,
|
|
};
|
|
|
|
stream_data.clear_subscriptions();
|
|
stream_data.add_sub('Canada', 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));
|
|
|
|
var warned = false;
|
|
blueslip.warn = function (msg) {
|
|
warned = true;
|
|
assert.equal(msg, 'Failed to delete stream does_not_exist');
|
|
};
|
|
stream_data.delete_sub('does_not_exist');
|
|
assert(warned);
|
|
blueslip.warn = function () {};
|
|
});
|
|
|
|
run_test('get_subscriber_count', () => {
|
|
var india = {
|
|
stream_id: 102,
|
|
name: 'India',
|
|
subscribed: true,
|
|
};
|
|
stream_data.clear_subscriptions();
|
|
assert.equal(stream_data.get_subscriber_count('India'), undefined);
|
|
stream_data.add_sub('India', india);
|
|
assert.equal(stream_data.get_subscriber_count('India'), 0);
|
|
|
|
var 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);
|
|
var 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);
|
|
|
|
var sub = stream_data.get_sub_by_name('India');
|
|
delete sub.subscribers;
|
|
assert.deepStrictEqual(stream_data.get_subscriber_count('India'), 0);
|
|
});
|
|
|
|
run_test('notifications', () => {
|
|
var india = {
|
|
stream_id: 102,
|
|
name: 'India',
|
|
subscribed: true,
|
|
desktop_notifications: true,
|
|
audible_notifications: true,
|
|
};
|
|
stream_data.clear_subscriptions();
|
|
stream_data.add_sub('India', india);
|
|
assert(stream_data.receives_desktop_notifications('India'));
|
|
assert(!stream_data.receives_desktop_notifications('Indiana'));
|
|
|
|
assert(stream_data.receives_audible_notifications('India'));
|
|
assert(!stream_data.receives_audible_notifications('Indiana'));
|
|
});
|
|
|
|
run_test('in_home_view', () => {
|
|
var tony = {
|
|
stream_id: 999,
|
|
name: 'tony',
|
|
subscribed: true,
|
|
in_home_view: true,
|
|
};
|
|
|
|
var jazy = {
|
|
stream_id: 500,
|
|
name: 'jazy',
|
|
subscribed: false,
|
|
in_home_view: false,
|
|
};
|
|
|
|
stream_data.add_sub('tony', tony);
|
|
stream_data.add_sub('jazy', jazy);
|
|
assert(stream_data.name_in_home_view('tony'));
|
|
assert(!stream_data.name_in_home_view('jazy'));
|
|
assert(!stream_data.name_in_home_view('EEXISTS'));
|
|
});
|
|
|
|
run_test('notifications_in_home_view', () => {
|
|
page_params.notifications_stream = 'tony';
|
|
assert(stream_data.notifications_in_home_view());
|
|
|
|
page_params.notifications_stream = 'jazy';
|
|
assert(!stream_data.notifications_in_home_view());
|
|
});
|
|
|
|
run_test('remove_default_stream', () => {
|
|
var remove_me = {
|
|
stream_id: 674,
|
|
name: 'remove_me',
|
|
subscribed: false,
|
|
in_home_view: false,
|
|
};
|
|
|
|
stream_data.add_sub('remove_me', remove_me);
|
|
stream_data.set_realm_default_streams([remove_me]);
|
|
stream_data.remove_default_stream(remove_me.stream_id);
|
|
assert(!stream_data.get_default_status('remove_me'));
|
|
assert.equal(page_params.realm_default_streams.length, 0);
|
|
});
|
|
|
|
run_test('render_stream_description', () => {
|
|
var desc = {
|
|
name: 'no_desc',
|
|
stream_id: 1002,
|
|
description: '<p>rendered desc</p>',
|
|
};
|
|
|
|
stream_data.add_sub('desc', desc);
|
|
var sub = stream_data.get_sub_by_name('desc');
|
|
stream_data.render_stream_description(sub);
|
|
assert.deepStrictEqual(sub.rendered_description, "rendered desc");
|
|
});
|
|
|
|
run_test('canonicalized_name', () => {
|
|
assert.deepStrictEqual(
|
|
stream_data.canonicalized_name('Stream_Bar'),
|
|
"stream_bar"
|
|
);
|
|
});
|
|
|
|
run_test('create_sub', () => {
|
|
stream_data.clear_subscriptions();
|
|
var india = {
|
|
stream_id: 102,
|
|
name: 'India',
|
|
subscribed: true,
|
|
};
|
|
|
|
var canada = {
|
|
name: 'Canada',
|
|
subscribed: true,
|
|
};
|
|
|
|
var antarctica = {
|
|
stream_id: 103,
|
|
name: 'Antarctica',
|
|
subscribed: true,
|
|
color: '#76ce90',
|
|
};
|
|
|
|
global.stream_color.pick_color = function () {
|
|
return '#bd86e5';
|
|
};
|
|
|
|
var india_sub = stream_data.create_sub_from_server_data('India', india);
|
|
assert(india_sub);
|
|
assert.equal(india_sub.color, '#bd86e5');
|
|
var 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);
|
|
|
|
var called = false;
|
|
global.blueslip.fatal = function (msg) {
|
|
assert.equal(msg, 'We cannot create a sub without a stream_id');
|
|
called = true;
|
|
};
|
|
var ok = stream_data.create_sub_from_server_data('Canada', canada);
|
|
assert.equal(ok, undefined);
|
|
assert(called);
|
|
|
|
var antarctica_sub = stream_data.create_sub_from_server_data('Antarctica', antarctica);
|
|
assert(antarctica_sub);
|
|
assert.equal(antarctica_sub.color, '#76ce90');
|
|
});
|
|
|
|
run_test('initialize_from_page_params', () => {
|
|
function initialize() {
|
|
page_params.subscriptions = [{
|
|
name: 'subscriptions',
|
|
}];
|
|
|
|
page_params.unsubscribed = [{
|
|
name: 'unsubscribed',
|
|
}];
|
|
|
|
page_params.never_subscribed = [{
|
|
name: 'never_subscribed',
|
|
}];
|
|
}
|
|
|
|
initialize();
|
|
page_params.realm_notifications_stream_id = -1;
|
|
stream_data.initialize_from_page_params();
|
|
|
|
assert(!page_params.subscriptions);
|
|
assert(!page_params.unsubscribed);
|
|
assert(!page_params.never_subscribed);
|
|
assert.equal(page_params.notifications_stream, "");
|
|
|
|
// Simulate a private stream the user isn't subscribed to
|
|
initialize();
|
|
page_params.realm_notifications_stream_id = 89;
|
|
stream_data.initialize_from_page_params();
|
|
assert.equal(page_params.notifications_stream, "");
|
|
|
|
// Now actually subscribe the user to the stream
|
|
initialize();
|
|
var foo = {
|
|
name: 'foo',
|
|
stream_id: 89,
|
|
};
|
|
|
|
stream_data.add_sub('foo', foo);
|
|
stream_data.initialize_from_page_params();
|
|
|
|
assert.equal(page_params.notifications_stream, "foo");
|
|
});
|
|
|
|
run_test('get_newbie_stream', () => {
|
|
var newbie = {
|
|
name: 'newbie',
|
|
stream_id: 234,
|
|
subscribed: true,
|
|
in_home_view: true,
|
|
};
|
|
|
|
var new_members = {
|
|
subscribed: true,
|
|
name: 'new members',
|
|
stream_id: 531,
|
|
};
|
|
|
|
assert.equal(stream_data.get_newbie_stream(), undefined);
|
|
|
|
stream_data.add_sub('newbie', newbie);
|
|
page_params.notifications_stream = 'newbie';
|
|
assert.equal(stream_data.get_newbie_stream(), 'newbie');
|
|
|
|
newbie.in_home_view = false;
|
|
assert.equal(stream_data.get_newbie_stream(), undefined);
|
|
|
|
stream_data.add_sub('new members', new_members);
|
|
assert.equal(stream_data.get_newbie_stream(), 'new members');
|
|
|
|
new_members.subscribed = false;
|
|
assert.equal(stream_data.get_newbie_stream(), undefined);
|
|
});
|
|
|
|
run_test('invite_streams', () => {
|
|
// add default stream
|
|
var orie = {
|
|
stream_id: 320,
|
|
name: 'Orie',
|
|
subscribed: true,
|
|
};
|
|
|
|
// clear all the data form stream_data, and people
|
|
stream_data.clear_subscriptions();
|
|
people.init();
|
|
|
|
stream_data.add_sub('Orie', orie);
|
|
stream_data.set_realm_default_streams([orie]);
|
|
|
|
var expected_list = ['Orie'];
|
|
assert.deepEqual(stream_data.invite_streams(), expected_list);
|
|
|
|
var inviter = {
|
|
stream_id: 25,
|
|
name: 'Inviter',
|
|
subscribed: true,
|
|
};
|
|
stream_data.add_sub('Inviter', inviter);
|
|
|
|
expected_list.push('Inviter');
|
|
assert.deepEqual(stream_data.invite_streams(), expected_list);
|
|
});
|