mirror of
https://github.com/zulip/zulip.git
synced 2025-11-10 00:46:03 +00:00
e64059de79
For all the places where we just make zero or one blueslip call, asserting for length is either unnecessary or overkill.
332 lines
9.6 KiB
JavaScript
332 lines
9.6 KiB
JavaScript
set_global('pm_conversations', {
|
|
recent: {},
|
|
});
|
|
|
|
zrequire('muting');
|
|
zrequire('unread');
|
|
zrequire('stream_data');
|
|
zrequire('topic_data');
|
|
zrequire('stream_sort');
|
|
const tg = zrequire('topic_generator');
|
|
|
|
function is_even(i) { return i % 2 === 0; }
|
|
function is_odd(i) { return i % 2 === 1; }
|
|
|
|
run_test('basics', () => {
|
|
let gen = tg.list_generator([10, 20, 30]);
|
|
assert.equal(gen.next(), 10);
|
|
assert.equal(gen.next(), 20);
|
|
assert.equal(gen.next(), 30);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
const gen1 = tg.list_generator([100, 200]);
|
|
const gen2 = tg.list_generator([300, 400]);
|
|
const outers = [gen1, gen2];
|
|
gen = tg.chain(outers);
|
|
assert.equal(gen.next(), 100);
|
|
assert.equal(gen.next(), 200);
|
|
assert.equal(gen.next(), 300);
|
|
assert.equal(gen.next(), 400);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.wrap([5, 15, 25, 35], 25);
|
|
assert.equal(gen.next(), 25);
|
|
assert.equal(gen.next(), 35);
|
|
assert.equal(gen.next(), 5);
|
|
assert.equal(gen.next(), 15);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.wrap_exclude([5, 15, 25, 35], 25);
|
|
assert.equal(gen.next(), 35);
|
|
assert.equal(gen.next(), 5);
|
|
assert.equal(gen.next(), 15);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.wrap([5, 15, 25, 35], undefined);
|
|
assert.equal(gen.next(), 5);
|
|
|
|
gen = tg.wrap_exclude([5, 15, 25, 35], undefined);
|
|
assert.equal(gen.next(), 5);
|
|
|
|
gen = tg.wrap([5, 15, 25, 35], 17);
|
|
assert.equal(gen.next(), 5);
|
|
|
|
gen = tg.wrap([], 42);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
let ints = tg.list_generator([1, 2, 3, 4, 5]);
|
|
gen = tg.filter(ints, is_even);
|
|
assert.equal(gen.next(), 2);
|
|
assert.equal(gen.next(), 4);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
ints = tg.list_generator([]);
|
|
gen = tg.filter(ints, is_even);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
ints = tg.list_generator([10, 20, 30]);
|
|
|
|
function mult10(x) { return x * 10; }
|
|
|
|
gen = tg.map(ints, mult10);
|
|
assert.equal(gen.next(), 100);
|
|
assert.equal(gen.next(), 200);
|
|
});
|
|
|
|
run_test('reverse', () => {
|
|
let gen = tg.reverse_list_generator([10, 20, 30]);
|
|
assert.equal(gen.next(), 30);
|
|
assert.equal(gen.next(), 20);
|
|
assert.equal(gen.next(), 10);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
// If second parameter is not in the list, we just traverse the list
|
|
// in reverse.
|
|
gen = tg.reverse_wrap_exclude([10, 20, 30]);
|
|
assert.equal(gen.next(), 30);
|
|
assert.equal(gen.next(), 20);
|
|
assert.equal(gen.next(), 10);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.reverse_wrap_exclude([10, 20, 30], 'whatever');
|
|
assert.equal(gen.next(), 30);
|
|
assert.equal(gen.next(), 20);
|
|
assert.equal(gen.next(), 10);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
// Witness the mostly typical cycling behavior.
|
|
gen = tg.reverse_wrap_exclude([5, 10, 20, 30], 20);
|
|
assert.equal(gen.next(), 10);
|
|
assert.equal(gen.next(), 5);
|
|
assert.equal(gen.next(), 30);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.reverse_wrap_exclude([5, 10, 20, 30], 5);
|
|
assert.equal(gen.next(), 30);
|
|
assert.equal(gen.next(), 20);
|
|
assert.equal(gen.next(), 10);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.reverse_wrap_exclude([5, 10, 20, 30], 30);
|
|
assert.equal(gen.next(), 20);
|
|
assert.equal(gen.next(), 10);
|
|
assert.equal(gen.next(), 5);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
// Test small lists.
|
|
gen = tg.reverse_wrap_exclude([], 5);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.reverse_wrap_exclude([5], 5);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
gen = tg.reverse_wrap_exclude([5], 10);
|
|
assert.equal(gen.next(), 5);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
});
|
|
|
|
run_test('fchain', () => {
|
|
const mults = function (n) {
|
|
let ret = 0;
|
|
return {
|
|
next: function () {
|
|
ret += n;
|
|
return ret <= 100 ? ret : undefined;
|
|
},
|
|
};
|
|
};
|
|
|
|
let ints = tg.list_generator([29, 43]);
|
|
let gen = tg.fchain(ints, mults);
|
|
assert.equal(gen.next(), 29);
|
|
assert.equal(gen.next(), 58);
|
|
assert.equal(gen.next(), 87);
|
|
assert.equal(gen.next(), 43);
|
|
assert.equal(gen.next(), 86);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
ints = tg.wrap([33, 34, 37], 37);
|
|
ints = tg.filter(ints, is_odd);
|
|
gen = tg.fchain(ints, mults);
|
|
assert.equal(gen.next(), 37);
|
|
assert.equal(gen.next(), 74);
|
|
assert.equal(gen.next(), 33);
|
|
assert.equal(gen.next(), 66);
|
|
assert.equal(gen.next(), 99);
|
|
assert.equal(gen.next(), undefined);
|
|
assert.equal(gen.next(), undefined);
|
|
|
|
const undef = function () {
|
|
return;
|
|
};
|
|
|
|
blueslip.expect('error', 'Invalid generator returned.');
|
|
ints = tg.list_generator([29, 43]);
|
|
gen = tg.fchain(ints, undef);
|
|
gen.next();
|
|
blueslip.reset();
|
|
});
|
|
|
|
run_test('streams', () => {
|
|
function assert_next_stream(curr_stream, expected) {
|
|
const actual = tg.get_next_stream(curr_stream);
|
|
assert.equal(actual, expected);
|
|
}
|
|
|
|
global.stream_sort.get_streams = function () {
|
|
return ['announce', 'muted', 'devel', 'test here'];
|
|
};
|
|
|
|
assert_next_stream(undefined, 'announce');
|
|
assert_next_stream('NOT THERE', 'announce');
|
|
|
|
assert_next_stream('announce', 'muted');
|
|
assert_next_stream('test here', 'announce');
|
|
|
|
function assert_prev_stream(curr_stream, expected) {
|
|
const actual = tg.get_prev_stream(curr_stream);
|
|
assert.equal(actual, expected);
|
|
}
|
|
|
|
assert_prev_stream(undefined, 'test here');
|
|
assert_prev_stream('test here', 'devel');
|
|
assert_prev_stream('announce', 'test here');
|
|
|
|
});
|
|
|
|
run_test('topics', () => {
|
|
const streams = [1, 2, 3, 4];
|
|
const topics = new Map([
|
|
[1, ['read', 'read', '1a', '1b', 'read', '1c']],
|
|
[2, []],
|
|
[3, ['3a', 'read', 'read', '3b', 'read']],
|
|
[4, ['4a']],
|
|
]);
|
|
|
|
function has_unread_messages(stream, topic) {
|
|
return topic !== 'read';
|
|
}
|
|
|
|
function get_topics(stream) {
|
|
return topics.get(stream);
|
|
}
|
|
|
|
function next_topic(curr_stream, curr_topic) {
|
|
return tg.next_topic(
|
|
streams,
|
|
get_topics,
|
|
has_unread_messages,
|
|
curr_stream,
|
|
curr_topic);
|
|
}
|
|
|
|
assert.deepEqual(next_topic(1, '1a'),
|
|
{stream: 1, topic: '1b'});
|
|
assert.deepEqual(next_topic(1, undefined),
|
|
{stream: 1, topic: '1a'});
|
|
assert.deepEqual(next_topic(2, 'bogus'),
|
|
{stream: 3, topic: '3a'});
|
|
assert.deepEqual(next_topic(3, '3b'),
|
|
{stream: 3, topic: '3a'});
|
|
assert.deepEqual(next_topic(4, '4a'),
|
|
{stream: 1, topic: '1a'});
|
|
assert.deepEqual(next_topic(undefined, undefined),
|
|
{stream: 1, topic: '1a'});
|
|
|
|
// Now test the deeper function that is wired up to
|
|
// real functions stream_data/stream_sort/unread.
|
|
|
|
global.stream_sort.get_streams = function () {
|
|
return ['announce', 'muted', 'devel', 'test here'];
|
|
};
|
|
|
|
const muted_stream_id = 400;
|
|
const devel_stream_id = 401;
|
|
|
|
const stream_id_dct = {
|
|
muted: muted_stream_id,
|
|
devel: devel_stream_id,
|
|
};
|
|
|
|
topic_data.get_recent_names = function (stream_id) {
|
|
switch (stream_id) {
|
|
case muted_stream_id:
|
|
return ['ms-topic1', 'ms-topic2'];
|
|
case devel_stream_id:
|
|
return ['muted', 'python'];
|
|
}
|
|
|
|
return [];
|
|
};
|
|
|
|
global.stream_data.get_stream_id = function (stream_name) {
|
|
return stream_id_dct[stream_name];
|
|
};
|
|
|
|
global.stream_data.is_stream_muted_by_name = function (stream_name) {
|
|
return stream_name === 'muted';
|
|
};
|
|
|
|
global.unread.topic_has_any_unread = function (stream_id) {
|
|
return [devel_stream_id, muted_stream_id].includes(stream_id);
|
|
};
|
|
|
|
global.muting.is_topic_muted = function (stream_name, topic) {
|
|
return topic === 'muted';
|
|
};
|
|
|
|
let next_item = tg.get_next_topic('announce', 'whatever');
|
|
assert.deepEqual(next_item, {
|
|
stream: 'devel',
|
|
topic: 'python',
|
|
});
|
|
|
|
next_item = tg.get_next_topic('muted', undefined);
|
|
assert.deepEqual(next_item, {
|
|
stream: 'muted',
|
|
topic: 'ms-topic1',
|
|
});
|
|
});
|
|
|
|
run_test('get_next_unread_pm_string', () => {
|
|
pm_conversations.recent.get_strings = function () {
|
|
return ['1', 'read', '2,3', '4', 'unk'];
|
|
};
|
|
|
|
unread.num_unread_for_person = function (user_ids_string) {
|
|
if (user_ids_string === 'unk') {
|
|
return;
|
|
}
|
|
|
|
if (user_ids_string === 'read') {
|
|
return 0;
|
|
}
|
|
|
|
return 5; // random non-zero value
|
|
};
|
|
|
|
assert.equal(tg.get_next_unread_pm_string(), '1');
|
|
assert.equal(tg.get_next_unread_pm_string('4'), '1');
|
|
assert.equal(tg.get_next_unread_pm_string('unk'), '1');
|
|
assert.equal(tg.get_next_unread_pm_string('4'), '1');
|
|
assert.equal(tg.get_next_unread_pm_string('1'), '2,3');
|
|
assert.equal(tg.get_next_unread_pm_string('read'), '2,3');
|
|
assert.equal(tg.get_next_unread_pm_string('2,3'), '4');
|
|
});
|