mirror of
https://github.com/zulip/zulip.git
synced 2025-11-02 04:53:36 +00:00
8d102cf12f
Updates the search suggestions in the web app to use the modern convention of "channel" and "channels". Also, updates the "from" search suggestions to use the modern canonical convention of "sender". Part of stream to channel rename project.
2029 lines
73 KiB
JavaScript
2029 lines
73 KiB
JavaScript
"use strict";
|
|
|
|
const {strict: assert} = require("assert");
|
|
|
|
const {parseOneAddress} = require("email-addresses");
|
|
|
|
const {mock_esm, with_overrides, zrequire} = require("./lib/namespace");
|
|
const {run_test} = require("./lib/test");
|
|
const blueslip = require("./lib/zblueslip");
|
|
const $ = require("./lib/zjquery");
|
|
const {page_params, realm} = require("./lib/zpage_params");
|
|
|
|
const message_store = mock_esm("../src/message_store");
|
|
|
|
const resolved_topic = zrequire("../shared/src/resolved_topic");
|
|
const stream_data = zrequire("stream_data");
|
|
const people = zrequire("people");
|
|
const {Filter} = zrequire("../src/filter");
|
|
|
|
const stream_message = "stream";
|
|
const direct_message = "private";
|
|
|
|
const me = {
|
|
email: "me@example.com",
|
|
user_id: 30,
|
|
full_name: "Me Myself",
|
|
};
|
|
|
|
const joe = {
|
|
email: "joe@example.com",
|
|
user_id: 31,
|
|
full_name: "joe",
|
|
};
|
|
|
|
const steve = {
|
|
email: "STEVE@foo.com",
|
|
user_id: 32,
|
|
full_name: "steve",
|
|
};
|
|
|
|
const alice = {
|
|
email: "alice@example.com",
|
|
user_id: 33,
|
|
full_name: "alice",
|
|
is_guest: true,
|
|
};
|
|
|
|
people.add_active_user(me);
|
|
people.add_active_user(joe);
|
|
people.add_active_user(steve);
|
|
people.add_active_user(alice);
|
|
people.initialize_current_user(me.user_id);
|
|
|
|
function assert_same_terms(result, terms) {
|
|
// If negated flag is undefined, we explicitly
|
|
// set it to false.
|
|
terms = terms.map(({negated = false, operator, operand}) => ({negated, operator, operand}));
|
|
assert.deepEqual(result, terms);
|
|
}
|
|
|
|
function get_predicate(raw_terms) {
|
|
const terms = raw_terms.map((op) => ({
|
|
operator: op[0],
|
|
operand: op[1],
|
|
}));
|
|
return new Filter(terms).predicate();
|
|
}
|
|
|
|
function make_sub(name, stream_id) {
|
|
const sub = {
|
|
name,
|
|
stream_id,
|
|
};
|
|
stream_data.add_sub(sub);
|
|
}
|
|
|
|
function test(label, f) {
|
|
run_test(label, (helpers) => {
|
|
stream_data.clear_subscriptions();
|
|
f(helpers);
|
|
});
|
|
}
|
|
|
|
test("basics", () => {
|
|
let terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "channel", operand: "exclude_me", negated: true},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
let filter = new Filter(terms);
|
|
|
|
assert_same_terms(filter.terms(), terms);
|
|
assert.deepEqual(filter.operands("channel"), ["foo"]);
|
|
|
|
assert.ok(filter.has_operator("channel"));
|
|
assert.ok(!filter.has_operator("search"));
|
|
|
|
assert.ok(filter.has_operand("channel", "foo"));
|
|
assert.ok(!filter.has_operand("channel", "exclude_me"));
|
|
assert.ok(!filter.has_operand("channel", "nada"));
|
|
|
|
assert.ok(!filter.is_keyword_search());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.allow_use_first_unread_when_narrowing());
|
|
assert.ok(filter.includes_full_stream_history());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
assert.ok(filter.can_bucket_by("channel"));
|
|
assert.ok(filter.can_bucket_by("channel", "topic"));
|
|
|
|
// "stream" was renamed to "channel"
|
|
terms = [{operator: "stream", operand: "foo"}];
|
|
assert.ok(filter.has_operator("channel"));
|
|
assert.deepEqual(filter.operands("channel"), ["foo"]);
|
|
assert.ok(filter.includes_full_stream_history());
|
|
assert.ok(filter.can_apply_locally());
|
|
|
|
terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "channel", operand: "exclude_me", negated: true},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
filter = new Filter(terms);
|
|
|
|
assert.deepEqual(filter.operands("channel"), ["foo"]);
|
|
|
|
assert.ok(filter.has_operator("channel"));
|
|
assert.ok(!filter.has_operator("search"));
|
|
|
|
assert.ok(filter.has_operand("channel", "foo"));
|
|
assert.ok(!filter.has_operand("channel", "exclude_me"));
|
|
assert.ok(!filter.has_operand("channel", "nada"));
|
|
|
|
assert.ok(!filter.is_keyword_search());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.allow_use_first_unread_when_narrowing());
|
|
assert.ok(filter.includes_full_stream_history());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
{operator: "search", operand: "pizza"},
|
|
];
|
|
filter = new Filter(terms);
|
|
|
|
assert.ok(filter.is_keyword_search());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(!filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.allow_use_first_unread_when_narrowing());
|
|
assert.ok(!filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(filter.can_bucket_by("channel"));
|
|
assert.ok(filter.can_bucket_by("channel", "topic"));
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
{operator: "near", operand: 17},
|
|
];
|
|
filter = new Filter(terms);
|
|
|
|
assert.ok(!filter.is_keyword_search());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.allow_use_first_unread_when_narrowing());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(filter.can_bucket_by("channel"));
|
|
assert.ok(filter.can_bucket_by("channel", "topic"));
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
// If our only channel operator is negated, then for all intents and purposes,
|
|
// we don't consider ourselves to have a channel operator, because we don't
|
|
// want to have the channel in the tab bar or unsubscribe messaging, etc.
|
|
terms = [{operator: "channel", operand: "exclude", negated: true}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.has_operator("channel"));
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
// Negated searches are just like positive searches for our purposes, since
|
|
// the search logic happens on the backend and we need to have can_apply_locally()
|
|
// be false, and we want "Search results" in the tab bar.
|
|
terms = [{operator: "search", operand: "stop_word", negated: true}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(filter.has_operator("search"));
|
|
assert.ok(!filter.can_apply_locally());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(!filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
// Similar logic applies to negated "has" searches.
|
|
terms = [{operator: "has", operand: "images", negated: true}];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.has_operator("has"));
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.can_apply_locally(true));
|
|
assert.ok(!filter.includes_full_stream_history());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(!filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
terms = [{operator: "channels", operand: "public", negated: true}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.has_operator("channels"));
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(filter.has_negated_operand("channels", "public"));
|
|
assert.ok(!filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
terms = [{operator: "channels", operand: "public"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(filter.has_operator("channels"));
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.has_negated_operand("channels", "public"));
|
|
assert.ok(!filter.can_apply_locally());
|
|
assert.ok(filter.includes_full_stream_history());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
// "streams" was renamed to "channels"
|
|
terms = [{operator: "streams", operand: "public"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.has_operator("channels"));
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(filter.includes_full_stream_history());
|
|
|
|
terms = [{operator: "is", operand: "dm"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.contains_only_private_messages());
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.has_operator("search"));
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
// "is:private" was renamed to "is:dm"
|
|
terms = [{operator: "is", operand: "private"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.has_operand("is", "dm"));
|
|
assert.ok(!filter.has_operand("is", "private"));
|
|
|
|
terms = [{operator: "is", operand: "mentioned"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(!filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.has_operator("search"));
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
terms = [{operator: "is", operand: "starred"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(!filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.has_operator("search"));
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
terms = [{operator: "dm", operand: "joe@example.com"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.is_non_huddle_pm());
|
|
assert.ok(filter.contains_only_private_messages());
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.has_operator("search"));
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(filter.is_conversation_view());
|
|
|
|
terms = [{operator: "dm", operand: "joe@example.com,jack@example.com"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.is_non_huddle_pm());
|
|
assert.ok(filter.contains_only_private_messages());
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(filter.is_conversation_view());
|
|
|
|
// "pm-with" was renamed to "dm"
|
|
terms = [{operator: "pm-with", operand: "joe@example.com"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.has_operator("dm"));
|
|
assert.ok(!filter.has_operator(" pm-with"));
|
|
|
|
terms = [{operator: "dm-including", operand: "joe@example.com"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.is_non_huddle_pm());
|
|
assert.ok(filter.contains_only_private_messages());
|
|
assert.ok(!filter.has_operator("search"));
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
// "group-pm-with" was replaced with "dm-including"
|
|
terms = [{operator: "group-pm-with", operand: "joe@example.com"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.has_operator("dm-including"));
|
|
assert.ok(!filter.has_operator("group-pm-with"));
|
|
|
|
terms = [{operator: "is", operand: "resolved"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.has_operator("search"));
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
// Highly complex query to exercise
|
|
// filter.supports_collapsing_recipients loop.
|
|
terms = [
|
|
{operator: "is", operand: "resolved", negated: true},
|
|
{operator: "is", operand: "dm", negated: true},
|
|
{operator: "channel", operand: "channel_name", negated: true},
|
|
{operator: "channels", operand: "web-public", negated: true},
|
|
{operator: "channels", operand: "public"},
|
|
{operator: "topic", operand: "patience", negated: true},
|
|
{operator: "in", operand: "all"},
|
|
];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(!filter.has_operator("search"));
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
// This next check verifies what is probably a bug; see the
|
|
// comment in the can_apply_locally implementation.
|
|
assert.ok(!filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(!filter.is_conversation_view());
|
|
|
|
terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
filter = new Filter(terms);
|
|
|
|
assert.ok(!filter.is_keyword_search());
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(filter.allow_use_first_unread_when_narrowing());
|
|
assert.ok(filter.includes_full_stream_history());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(filter.is_conversation_view());
|
|
|
|
// "stream" was renamed to "channel"
|
|
terms = [
|
|
{operator: "stream", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
filter = new Filter(terms);
|
|
|
|
assert.ok(!filter.is_keyword_search());
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.supports_collapsing_recipients());
|
|
assert.ok(!filter.contains_only_private_messages());
|
|
assert.ok(filter.allow_use_first_unread_when_narrowing());
|
|
assert.ok(filter.includes_full_stream_history());
|
|
assert.ok(filter.can_apply_locally());
|
|
assert.ok(!filter.is_personal_filter());
|
|
assert.ok(filter.is_conversation_view());
|
|
});
|
|
|
|
function assert_not_mark_read_with_has_operands(additional_terms_to_test) {
|
|
additional_terms_to_test = additional_terms_to_test || [];
|
|
let has_link_term = [{operator: "has", operand: "link"}];
|
|
let filter = new Filter([...additional_terms_to_test, ...has_link_term]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
has_link_term = [{operator: "has", operand: "link", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...has_link_term]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
has_link_term = [{operator: "has", operand: "image"}];
|
|
filter = new Filter([...additional_terms_to_test, ...has_link_term]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
has_link_term = [{operator: "has", operand: "image", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...has_link_term]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
has_link_term = [{operator: "has", operand: "attachment", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...has_link_term]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
has_link_term = [{operator: "has", operand: "attachment"}];
|
|
filter = new Filter([...additional_terms_to_test, ...has_link_term]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
}
|
|
function assert_not_mark_read_with_is_operands(additional_terms_to_test) {
|
|
additional_terms_to_test = additional_terms_to_test || [];
|
|
let is_operator = [{operator: "is", operand: "starred"}];
|
|
let filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "starred", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "mentioned"}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "mentioned", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "alerted"}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "alerted", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "unread"}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "unread", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
is_operator = [{operator: "is", operand: "resolved"}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
if (additional_terms_to_test.length === 0) {
|
|
assert.ok(filter.can_mark_messages_read());
|
|
} else {
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
}
|
|
|
|
is_operator = [{operator: "is", operand: "resolved", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...is_operator]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
}
|
|
|
|
function assert_not_mark_read_when_searching(additional_terms_to_test) {
|
|
additional_terms_to_test = additional_terms_to_test || [];
|
|
let search_op = [{operator: "search", operand: "keyword"}];
|
|
let filter = new Filter([...additional_terms_to_test, ...search_op]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
search_op = [{operator: "search", operand: "keyword", negated: true}];
|
|
filter = new Filter([...additional_terms_to_test, ...search_op]);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
}
|
|
|
|
test("can_mark_messages_read", () => {
|
|
assert_not_mark_read_with_has_operands();
|
|
assert_not_mark_read_with_is_operands();
|
|
assert_not_mark_read_when_searching();
|
|
|
|
const channel_term = [{operator: "channel", operand: "foo"}];
|
|
let filter = new Filter(channel_term);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert_not_mark_read_with_has_operands(channel_term);
|
|
assert_not_mark_read_with_is_operands(channel_term);
|
|
assert_not_mark_read_when_searching(channel_term);
|
|
|
|
const channel_negated_operator = [{operator: "channel", operand: "foo", negated: true}];
|
|
filter = new Filter(channel_negated_operator);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
const channel_topic_terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
filter = new Filter(channel_topic_terms);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert_not_mark_read_with_has_operands(channel_topic_terms);
|
|
assert_not_mark_read_with_is_operands(channel_topic_terms);
|
|
assert_not_mark_read_when_searching(channel_topic_terms);
|
|
|
|
const channel_negated_topic_terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar", negated: true},
|
|
];
|
|
filter = new Filter(channel_negated_topic_terms);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
const dm = [{operator: "dm", operand: "joe@example.com,"}];
|
|
|
|
const dm_negated = [{operator: "dm", operand: "joe@example.com,", negated: true}];
|
|
|
|
const dm_group = [{operator: "dm", operand: "joe@example.com,STEVE@foo.com"}];
|
|
filter = new Filter(dm);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
filter = new Filter(dm_negated);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
filter = new Filter(dm_group);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert_not_mark_read_with_is_operands(dm_group);
|
|
assert_not_mark_read_with_is_operands(dm);
|
|
assert_not_mark_read_with_has_operands(dm_group);
|
|
assert_not_mark_read_with_has_operands(dm);
|
|
assert_not_mark_read_when_searching(dm_group);
|
|
assert_not_mark_read_when_searching(dm);
|
|
|
|
const is_dm = [{operator: "is", operand: "dm"}];
|
|
filter = new Filter(is_dm);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert_not_mark_read_with_is_operands(is_dm);
|
|
assert_not_mark_read_with_has_operands(is_dm);
|
|
assert_not_mark_read_when_searching(is_dm);
|
|
|
|
const in_all = [{operator: "in", operand: "all"}];
|
|
filter = new Filter(in_all);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert_not_mark_read_with_is_operands(in_all);
|
|
assert_not_mark_read_with_has_operands(in_all);
|
|
assert_not_mark_read_when_searching(in_all);
|
|
|
|
const in_home = [{operator: "in", operand: "home"}];
|
|
const in_home_negated = [{operator: "in", operand: "home", negated: true}];
|
|
filter = new Filter(in_home);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert_not_mark_read_with_is_operands(in_home);
|
|
assert_not_mark_read_with_has_operands(in_home);
|
|
assert_not_mark_read_when_searching(in_home);
|
|
filter = new Filter(in_home_negated);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
// Do not mark messages as read when in an unsupported 'in:*' filter.
|
|
const in_random = [{operator: "in", operand: "xxxxxxxxx"}];
|
|
const in_random_negated = [{operator: "in", operand: "xxxxxxxxx", negated: true}];
|
|
filter = new Filter(in_random);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
filter = new Filter(in_random_negated);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
|
|
// test caching of term types
|
|
// init and stub
|
|
filter = new Filter(dm);
|
|
filter.stub = filter.calc_can_mark_messages_read;
|
|
filter.calc_can_mark_messages_read = function () {
|
|
this.calc_can_mark_messages_read_called = true;
|
|
return this.stub();
|
|
};
|
|
|
|
// uncached trial
|
|
filter.calc_can_mark_messages_read_called = false;
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.calc_can_mark_messages_read_called);
|
|
|
|
// cached trial
|
|
filter.calc_can_mark_messages_read_called = false;
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(!filter.calc_can_mark_messages_read_called);
|
|
});
|
|
|
|
test("show_first_unread", () => {
|
|
let terms = [{operator: "is", operand: "any"}];
|
|
let filter = new Filter(terms);
|
|
assert.ok(filter.allow_use_first_unread_when_narrowing());
|
|
|
|
terms = [{operator: "search", operand: "query to search"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.allow_use_first_unread_when_narrowing());
|
|
|
|
filter = new Filter([]);
|
|
assert.ok(filter.can_mark_messages_read());
|
|
assert.ok(filter.allow_use_first_unread_when_narrowing());
|
|
|
|
// Side case
|
|
terms = [{operator: "is", operand: "any"}];
|
|
filter = new Filter(terms);
|
|
assert.ok(!filter.can_mark_messages_read());
|
|
assert.ok(filter.allow_use_first_unread_when_narrowing());
|
|
});
|
|
|
|
test("filter_with_new_params_topic", () => {
|
|
const terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "old topic"},
|
|
];
|
|
const filter = new Filter(terms);
|
|
|
|
assert.ok(filter.has_topic("foo", "old topic"));
|
|
assert.ok(!filter.has_topic("wrong", "old topic"));
|
|
assert.ok(!filter.has_topic("foo", "wrong"));
|
|
|
|
const new_filter = filter.filter_with_new_params({
|
|
operator: "topic",
|
|
operand: "new topic",
|
|
});
|
|
|
|
assert.deepEqual(new_filter.operands("channel"), ["foo"]);
|
|
assert.deepEqual(new_filter.operands("topic"), ["new topic"]);
|
|
});
|
|
|
|
test("filter_with_new_params_channel", () => {
|
|
const terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "old topic"},
|
|
];
|
|
const filter = new Filter(terms);
|
|
|
|
assert.ok(filter.has_topic("foo", "old topic"));
|
|
assert.ok(!filter.has_topic("wrong", "old topic"));
|
|
assert.ok(!filter.has_topic("foo", "wrong"));
|
|
|
|
const new_filter = filter.filter_with_new_params({
|
|
operator: "channel",
|
|
operand: "new channel",
|
|
});
|
|
|
|
assert.deepEqual(new_filter.operands("channel"), ["new channel"]);
|
|
assert.deepEqual(new_filter.operands("topic"), ["old topic"]);
|
|
});
|
|
|
|
test("new_style_terms", () => {
|
|
const term = {
|
|
operator: "channel",
|
|
operand: "foo",
|
|
};
|
|
const terms = [term];
|
|
const filter = new Filter(terms);
|
|
|
|
assert.deepEqual(filter.operands("channel"), ["foo"]);
|
|
assert.ok(filter.can_bucket_by("channel"));
|
|
});
|
|
|
|
test("public_terms", ({override}) => {
|
|
stream_data.clear_subscriptions();
|
|
let terms = [
|
|
{operator: "channel", operand: "some_channel"},
|
|
{operator: "in", operand: "all"},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
let filter = new Filter(terms);
|
|
const expected_terms = [
|
|
{operator: "channel", operand: "some_channel"},
|
|
{operator: "in", operand: "all"},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
override(page_params, "narrow_stream", undefined);
|
|
assert_same_terms(filter.public_terms(), expected_terms);
|
|
assert.ok(filter.can_bucket_by("channel"));
|
|
|
|
terms = [{operator: "channel", operand: "default"}];
|
|
filter = new Filter(terms);
|
|
override(page_params, "narrow_stream", "default");
|
|
assert_same_terms(filter.public_terms(), []);
|
|
});
|
|
|
|
test("redundancies", () => {
|
|
let terms;
|
|
let filter;
|
|
|
|
terms = [
|
|
{operator: "dm", operand: "joe@example.com,"},
|
|
{operator: "is", operand: "dm"},
|
|
];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.can_bucket_by("dm"));
|
|
|
|
terms = [
|
|
{operator: "dm", operand: "joe@example.com,", negated: true},
|
|
{operator: "is", operand: "dm"},
|
|
];
|
|
filter = new Filter(terms);
|
|
assert.ok(filter.can_bucket_by("is-dm", "not-dm"));
|
|
});
|
|
|
|
test("canonicalization", () => {
|
|
assert.equal(Filter.canonicalize_operator("Is"), "is");
|
|
assert.equal(Filter.canonicalize_operator("Stream"), "channel");
|
|
assert.equal(Filter.canonicalize_operator("Subject"), "topic");
|
|
assert.equal(Filter.canonicalize_operator("FROM"), "sender");
|
|
|
|
let term;
|
|
term = Filter.canonicalize_term({operator: "Stream", operand: "Denmark"});
|
|
assert.equal(term.operator, "channel");
|
|
assert.equal(term.operand, "Denmark");
|
|
|
|
term = Filter.canonicalize_term({operator: "Channel", operand: "Denmark"});
|
|
assert.equal(term.operator, "channel");
|
|
assert.equal(term.operand, "Denmark");
|
|
|
|
term = Filter.canonicalize_term({operator: "sender", operand: "me"});
|
|
assert.equal(term.operator, "sender");
|
|
assert.equal(term.operand, "me@example.com");
|
|
|
|
// "pm-with" was renamed to "dm"
|
|
term = Filter.canonicalize_term({operator: "pm-with", operand: "me"});
|
|
assert.equal(term.operator, "dm");
|
|
assert.equal(term.operand, "me@example.com");
|
|
|
|
// "group-pm-with" was replaced with "dm-including"
|
|
term = Filter.canonicalize_term({operator: "group-pm-with", operand: "joe@example.com"});
|
|
assert.equal(term.operator, "dm-including");
|
|
assert.equal(term.operand, "joe@example.com");
|
|
|
|
term = Filter.canonicalize_term({operator: "search", operand: "foo"});
|
|
assert.equal(term.operator, "search");
|
|
assert.equal(term.operand, "foo");
|
|
|
|
term = Filter.canonicalize_term({operator: "search", operand: "fOO"});
|
|
assert.equal(term.operator, "search");
|
|
assert.equal(term.operand, "foo");
|
|
|
|
term = Filter.canonicalize_term({operator: "search", operand: 123});
|
|
assert.equal(term.operator, "search");
|
|
assert.equal(term.operand, "123");
|
|
|
|
term = Filter.canonicalize_term({operator: "search", operand: "abc “xyz”"});
|
|
assert.equal(term.operator, "search");
|
|
assert.equal(term.operand, 'abc "xyz"');
|
|
|
|
term = Filter.canonicalize_term({operator: "has", operand: "attachments"});
|
|
assert.equal(term.operator, "has");
|
|
assert.equal(term.operand, "attachment");
|
|
|
|
term = Filter.canonicalize_term({operator: "has", operand: "images"});
|
|
assert.equal(term.operator, "has");
|
|
assert.equal(term.operand, "image");
|
|
|
|
term = Filter.canonicalize_term({operator: "has", operand: "links"});
|
|
assert.equal(term.operator, "has");
|
|
assert.equal(term.operand, "link");
|
|
});
|
|
|
|
test("predicate_basics", () => {
|
|
// Predicates are functions that accept a message object with the message
|
|
// attributes (not content), and return true if the message belongs in a
|
|
// given narrow. If the narrow parameters include a search, the predicate
|
|
// passes through all messages.
|
|
//
|
|
// To keep these tests simple, we only pass objects with a few relevant attributes
|
|
// rather than full-fledged message objects.
|
|
|
|
const stream_id = 42;
|
|
make_sub("Foo", stream_id);
|
|
let predicate = get_predicate([
|
|
["channel", "Foo"],
|
|
["topic", "Bar"],
|
|
]);
|
|
|
|
assert.ok(predicate({type: stream_message, stream_id, topic: "bar"}));
|
|
assert.ok(!predicate({type: stream_message, stream_id, topic: "whatever"}));
|
|
// 9999999 doesn't exist, testing no match
|
|
assert.ok(!predicate({type: stream_message, stream_id: 9999999}));
|
|
assert.ok(!predicate({type: direct_message}));
|
|
|
|
// For old channels that we are no longer subscribed to, we may not have
|
|
// a subscription, but these should still match by channel name.
|
|
const old_sub = {
|
|
name: "old-subscription",
|
|
stream_id: 5,
|
|
subscribed: false,
|
|
};
|
|
stream_data.add_sub(old_sub);
|
|
predicate = get_predicate([
|
|
["channel", "old-subscription"],
|
|
["topic", "Bar"],
|
|
]);
|
|
assert.ok(predicate({type: stream_message, stream_id: 5, topic: "bar"}));
|
|
// 99999 doesn't exist, testing no match
|
|
assert.ok(!predicate({type: stream_message, stream_id: 99999, topic: "whatever"}));
|
|
|
|
predicate = get_predicate([["search", "emoji"]]);
|
|
assert.ok(predicate({}));
|
|
|
|
predicate = get_predicate([["topic", "Bar"]]);
|
|
assert.ok(!predicate({type: direct_message}));
|
|
|
|
predicate = get_predicate([["is", "dm"]]);
|
|
assert.ok(predicate({type: direct_message}));
|
|
assert.ok(!predicate({type: stream_message}));
|
|
|
|
predicate = get_predicate([["channels", "public"]]);
|
|
assert.ok(predicate({}));
|
|
|
|
predicate = get_predicate([["is", "starred"]]);
|
|
assert.ok(predicate({starred: true}));
|
|
assert.ok(!predicate({starred: false}));
|
|
|
|
predicate = get_predicate([["is", "unread"]]);
|
|
assert.ok(predicate({unread: true}));
|
|
assert.ok(!predicate({unread: false}));
|
|
|
|
predicate = get_predicate([["is", "alerted"]]);
|
|
assert.ok(predicate({alerted: true}));
|
|
assert.ok(!predicate({alerted: false}));
|
|
assert.ok(!predicate({}));
|
|
|
|
predicate = get_predicate([["is", "mentioned"]]);
|
|
assert.ok(predicate({mentioned: true}));
|
|
assert.ok(!predicate({mentioned: false}));
|
|
|
|
predicate = get_predicate([["in", "all"]]);
|
|
assert.ok(predicate({}));
|
|
|
|
predicate = get_predicate([["is", "resolved"]]);
|
|
const resolved_topic_name = resolved_topic.resolve_name("foo");
|
|
assert.ok(predicate({type: stream_message, topic: resolved_topic_name}));
|
|
assert.ok(!predicate({topic: resolved_topic_name}));
|
|
assert.ok(!predicate({type: stream_message, topic: "foo"}));
|
|
|
|
const unknown_stream_id = 999;
|
|
predicate = get_predicate([["in", "home"]]);
|
|
assert.ok(!predicate({stream_id: unknown_stream_id, stream: "unknown"}));
|
|
assert.ok(predicate({type: direct_message}));
|
|
|
|
make_sub("kiosk", 1234);
|
|
with_overrides(({override}) => {
|
|
override(page_params, "narrow_stream", "kiosk");
|
|
assert.ok(predicate({stream_id: 1234}));
|
|
});
|
|
|
|
predicate = get_predicate([["near", 5]]);
|
|
assert.ok(predicate({}));
|
|
|
|
predicate = get_predicate([["id", 5]]);
|
|
assert.ok(predicate({id: 5}));
|
|
assert.ok(!predicate({id: 6}));
|
|
|
|
predicate = get_predicate([
|
|
["id", 5],
|
|
["topic", "lunch"],
|
|
]);
|
|
assert.ok(predicate({type: stream_message, id: 5, topic: "lunch"}));
|
|
assert.ok(!predicate({type: stream_message, id: 5, topic: "dinner"}));
|
|
|
|
predicate = get_predicate([["sender", "Joe@example.com"]]);
|
|
assert.ok(predicate({sender_id: joe.user_id}));
|
|
assert.ok(!predicate({sender_email: steve.user_id}));
|
|
|
|
predicate = get_predicate([["dm", "Joe@example.com"]]);
|
|
assert.ok(
|
|
predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: joe.user_id}],
|
|
}),
|
|
);
|
|
assert.ok(
|
|
!predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: steve.user_id}],
|
|
}),
|
|
);
|
|
assert.ok(
|
|
!predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: 999999}],
|
|
}),
|
|
);
|
|
assert.ok(!predicate({type: stream_message}));
|
|
|
|
predicate = get_predicate([["dm", "Joe@example.com,steve@foo.com"]]);
|
|
assert.ok(
|
|
predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: joe.user_id}, {id: steve.user_id}],
|
|
}),
|
|
);
|
|
|
|
// Make sure your own email is ignored
|
|
predicate = get_predicate([["dm", "Joe@example.com,steve@foo.com,me@example.com"]]);
|
|
assert.ok(
|
|
predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: joe.user_id}, {id: steve.user_id}],
|
|
}),
|
|
);
|
|
|
|
predicate = get_predicate([["dm", "nobody@example.com"]]);
|
|
assert.ok(
|
|
!predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: joe.user_id}],
|
|
}),
|
|
);
|
|
|
|
predicate = get_predicate([["dm-including", "nobody@example.com"]]);
|
|
assert.ok(
|
|
!predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: joe.user_id}, {id: me.user_id}],
|
|
}),
|
|
);
|
|
|
|
predicate = get_predicate([["dm-including", "Joe@example.com"]]);
|
|
assert.ok(
|
|
predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: joe.user_id}, {id: steve.user_id}, {id: me.user_id}],
|
|
}),
|
|
);
|
|
assert.ok(
|
|
predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: joe.user_id}, {id: me.user_id}],
|
|
}),
|
|
);
|
|
assert.ok(
|
|
!predicate({
|
|
type: direct_message,
|
|
display_recipient: [{id: steve.user_id}, {id: me.user_id}],
|
|
}),
|
|
);
|
|
assert.ok(!predicate({type: stream_message}));
|
|
|
|
const img_msg = {
|
|
content:
|
|
'<p><a href="/user_uploads/randompath/test.jpeg">test.jpeg</a></p><div class="message_inline_image"><a href="/user_uploads/randompath/test.jpeg" title="test.jpeg"><img src="/user_uploads/randompath/test.jpeg"></a></div>',
|
|
};
|
|
|
|
const link_msg = {
|
|
content: '<p><a href="http://chat.zulip.org">chat.zulip.org</a></p>',
|
|
};
|
|
|
|
const non_img_attachment_msg = {
|
|
content: '<p><a href="/user_uploads/randompath/attachment.ext">attachment.ext</a></p>',
|
|
};
|
|
|
|
const no_has_filter_matching_msg = {
|
|
content: "<p>Testing</p>",
|
|
};
|
|
|
|
predicate = get_predicate([["has", "non_valid_operand"]]);
|
|
assert.ok(!predicate(img_msg));
|
|
assert.ok(!predicate(non_img_attachment_msg));
|
|
assert.ok(!predicate(link_msg));
|
|
assert.ok(!predicate(no_has_filter_matching_msg));
|
|
|
|
// HTML content of message is used to determine if image have link, image or attachment.
|
|
// We are using jquery to parse the html and find existence of relevant tags/elements.
|
|
// In tests we need to stub the calls to jquery so using zjquery's .set_find_results method.
|
|
function set_find_results_for_msg_content(msg, jquery_selector, results) {
|
|
$(`<div>${msg.content}</div>`).set_find_results(jquery_selector, results);
|
|
}
|
|
|
|
const has_link = get_predicate([["has", "link"]]);
|
|
set_find_results_for_msg_content(img_msg, "a", ["stub"]);
|
|
assert.ok(has_link(img_msg));
|
|
set_find_results_for_msg_content(non_img_attachment_msg, "a", ["stub"]);
|
|
assert.ok(has_link(non_img_attachment_msg));
|
|
set_find_results_for_msg_content(link_msg, "a", ["stub"]);
|
|
assert.ok(has_link(link_msg));
|
|
set_find_results_for_msg_content(no_has_filter_matching_msg, "a", false);
|
|
assert.ok(!has_link(no_has_filter_matching_msg));
|
|
|
|
const has_attachment = get_predicate([["has", "attachment"]]);
|
|
set_find_results_for_msg_content(img_msg, "a[href^='/user_uploads']", ["stub"]);
|
|
assert.ok(has_attachment(img_msg));
|
|
set_find_results_for_msg_content(non_img_attachment_msg, "a[href^='/user_uploads']", ["stub"]);
|
|
assert.ok(has_attachment(non_img_attachment_msg));
|
|
set_find_results_for_msg_content(link_msg, "a[href^='/user_uploads']", false);
|
|
assert.ok(!has_attachment(link_msg));
|
|
set_find_results_for_msg_content(no_has_filter_matching_msg, "a[href^='/user_uploads']", false);
|
|
assert.ok(!has_attachment(no_has_filter_matching_msg));
|
|
|
|
const has_image = get_predicate([["has", "image"]]);
|
|
set_find_results_for_msg_content(img_msg, ".message_inline_image", ["stub"]);
|
|
assert.ok(has_image(img_msg));
|
|
set_find_results_for_msg_content(non_img_attachment_msg, ".message_inline_image", false);
|
|
assert.ok(!has_image(non_img_attachment_msg));
|
|
set_find_results_for_msg_content(link_msg, ".message_inline_image", false);
|
|
assert.ok(!has_image(link_msg));
|
|
set_find_results_for_msg_content(no_has_filter_matching_msg, ".message_inline_image", false);
|
|
assert.ok(!has_image(no_has_filter_matching_msg));
|
|
});
|
|
|
|
test("negated_predicates", () => {
|
|
let predicate;
|
|
let narrow;
|
|
|
|
const social_stream_id = 555;
|
|
make_sub("social", social_stream_id);
|
|
|
|
narrow = [{operator: "channel", operand: "social", negated: true}];
|
|
predicate = new Filter(narrow).predicate();
|
|
assert.ok(predicate({type: stream_message, stream_id: 999999}));
|
|
assert.ok(!predicate({type: stream_message, stream_id: social_stream_id}));
|
|
|
|
narrow = [{operator: "channels", operand: "public", negated: true}];
|
|
predicate = new Filter(narrow).predicate();
|
|
assert.ok(predicate({}));
|
|
});
|
|
|
|
function test_mit_exceptions() {
|
|
const foo_stream_id = 555;
|
|
make_sub("Foo", foo_stream_id);
|
|
let predicate = get_predicate([
|
|
["channel", "Foo"],
|
|
["topic", "personal"],
|
|
]);
|
|
assert.ok(predicate({type: stream_message, stream_id: foo_stream_id, topic: "personal"}));
|
|
assert.ok(predicate({type: stream_message, stream_id: foo_stream_id, topic: ""}));
|
|
// 9999 doesn't correspond to any channel
|
|
assert.ok(!predicate({type: stream_message, stream_id: 9999}));
|
|
assert.ok(!predicate({type: stream_message, stream_id: foo_stream_id, topic: "whatever"}));
|
|
assert.ok(!predicate({type: direct_message}));
|
|
|
|
predicate = get_predicate([
|
|
["channel", "Foo"],
|
|
["topic", "bar"],
|
|
]);
|
|
assert.ok(predicate({type: stream_message, stream_id: foo_stream_id, topic: "bar.d"}));
|
|
|
|
// Try to get the MIT regex to explode for an empty channel.
|
|
let terms = [
|
|
{operator: "channel", operand: ""},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
predicate = new Filter(terms).predicate();
|
|
assert.ok(!predicate({type: stream_message, stream_id: foo_stream_id, topic: "bar"}));
|
|
|
|
// Try to get the MIT regex to explode for an empty topic.
|
|
terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: ""},
|
|
];
|
|
predicate = new Filter(terms).predicate();
|
|
assert.ok(!predicate({type: stream_message, stream_id: foo_stream_id, topic: "bar"}));
|
|
}
|
|
|
|
test("mit_exceptions", ({override}) => {
|
|
override(realm, "realm_is_zephyr_mirror_realm", true);
|
|
test_mit_exceptions();
|
|
});
|
|
|
|
test("predicate_edge_cases", () => {
|
|
let predicate;
|
|
// The code supports undefined as an operator to Filter, which results
|
|
// in a predicate that accepts any message.
|
|
predicate = new Filter([]).predicate();
|
|
assert.ok(predicate({}));
|
|
|
|
// Upstream code should prevent Filter.predicate from being called with
|
|
// invalid operator/operand combinations, but right now we just silently
|
|
// return a function that accepts all messages.
|
|
predicate = get_predicate([["in", "bogus"]]);
|
|
assert.ok(!predicate({}));
|
|
|
|
predicate = get_predicate([["bogus", 33]]);
|
|
assert.ok(predicate({}));
|
|
|
|
predicate = get_predicate([["is", "bogus"]]);
|
|
assert.ok(!predicate({}));
|
|
|
|
// Exercise caching feature.
|
|
const stream_id = 101;
|
|
make_sub("Off topic", stream_id);
|
|
const terms = [
|
|
{operator: "channel", operand: "Off topic"},
|
|
{operator: "topic", operand: "Mars"},
|
|
];
|
|
const filter = new Filter(terms);
|
|
filter.predicate();
|
|
predicate = filter.predicate(); // get cached version
|
|
assert.ok(predicate({type: stream_message, stream_id, topic: "Mars"}));
|
|
});
|
|
|
|
test("parse", () => {
|
|
let string;
|
|
let terms;
|
|
|
|
function _test() {
|
|
const result = Filter.parse(string);
|
|
assert_same_terms(result, terms);
|
|
}
|
|
|
|
string = "channel:Foo topic:Bar yo";
|
|
terms = [
|
|
{operator: "channel", operand: "Foo"},
|
|
{operator: "topic", operand: "Bar"},
|
|
{operator: "search", operand: "yo"},
|
|
];
|
|
_test();
|
|
|
|
// "stream" was renamed to "channel"
|
|
string = "stream:Foo topic:Bar yo";
|
|
terms = [
|
|
{operator: "stream", operand: "Foo"},
|
|
{operator: "topic", operand: "Bar"},
|
|
{operator: "search", operand: "yo"},
|
|
];
|
|
_test();
|
|
|
|
string = "dm:leo+test@zulip.com";
|
|
terms = [{operator: "dm", operand: "leo+test@zulip.com"}];
|
|
_test();
|
|
|
|
string = "sender:leo+test@zulip.com";
|
|
terms = [{operator: "sender", operand: "leo+test@zulip.com"}];
|
|
_test();
|
|
|
|
string = "channel:With+Space";
|
|
terms = [{operator: "channel", operand: "With Space"}];
|
|
_test();
|
|
|
|
string = 'channel:"with quoted space" topic:and separate';
|
|
terms = [
|
|
{operator: "channel", operand: "with quoted space"},
|
|
{operator: "topic", operand: "and"},
|
|
{operator: "search", operand: "separate"},
|
|
];
|
|
_test();
|
|
|
|
string = 'channel:"unclosed quote';
|
|
terms = [{operator: "channel", operand: "unclosed quote"}];
|
|
_test();
|
|
|
|
string = 'channel:""';
|
|
terms = [{operator: "channel", operand: ""}];
|
|
_test();
|
|
|
|
string = "https://www.google.com";
|
|
terms = [{operator: "search", operand: "https://www.google.com"}];
|
|
_test();
|
|
|
|
string = "channel:foo -channel:exclude";
|
|
terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "channel", operand: "exclude", negated: true},
|
|
];
|
|
_test();
|
|
|
|
string = "text channel:foo more text";
|
|
terms = [
|
|
{operator: "search", operand: "text"},
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "search", operand: "more text"},
|
|
];
|
|
_test();
|
|
|
|
string = "text channels:public more text";
|
|
terms = [
|
|
{operator: "search", operand: "text"},
|
|
{operator: "channels", operand: "public"},
|
|
{operator: "search", operand: "more text"},
|
|
];
|
|
_test();
|
|
|
|
string = "channels:public";
|
|
terms = [{operator: "channels", operand: "public"}];
|
|
_test();
|
|
|
|
string = "-channels:public";
|
|
terms = [{operator: "channels", operand: "public", negated: true}];
|
|
_test();
|
|
|
|
// "streams" was renamed to "channels"
|
|
string = "streams:public";
|
|
terms = [{operator: "streams", operand: "public"}];
|
|
_test();
|
|
|
|
string = "channel:foo :emoji: are cool";
|
|
terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "search", operand: ":emoji: are cool"},
|
|
];
|
|
_test();
|
|
|
|
string = ":channel: channel:foo :emoji: are cool";
|
|
terms = [
|
|
{operator: "search", operand: ":channel:"},
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "search", operand: ":emoji: are cool"},
|
|
];
|
|
_test();
|
|
|
|
string = ":channel: channel:foo -:emoji: are cool";
|
|
terms = [
|
|
{operator: "search", operand: ":channel:"},
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "search", operand: "-:emoji: are cool"},
|
|
];
|
|
_test();
|
|
|
|
string = "";
|
|
terms = [];
|
|
_test();
|
|
|
|
string = 'channel: separated topic: "with space"';
|
|
terms = [
|
|
{operator: "channel", operand: "separated"},
|
|
{operator: "topic", operand: "with space"},
|
|
];
|
|
_test();
|
|
});
|
|
|
|
test("unparse", () => {
|
|
let string;
|
|
let terms;
|
|
|
|
terms = [
|
|
{operator: "channel", operand: "Foo"},
|
|
{operator: "topic", operand: "Bar", negated: true},
|
|
{operator: "search", operand: "yo"},
|
|
];
|
|
string = "channel:Foo -topic:Bar yo";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
|
|
terms = [
|
|
{operator: "channels", operand: "public"},
|
|
{operator: "search", operand: "text"},
|
|
];
|
|
|
|
string = "channels:public text";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
|
|
terms = [{operator: "channels", operand: "public"}];
|
|
string = "channels:public";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
|
|
terms = [{operator: "channels", operand: "public", negated: true}];
|
|
string = "-channels:public";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
|
|
terms = [{operator: "id", operand: 50}];
|
|
string = "id:50";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
|
|
terms = [{operator: "near", operand: 150}];
|
|
string = "near:150";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
|
|
terms = [{operator: "", operand: ""}];
|
|
string = "";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
|
|
// canonical version of the operator is
|
|
// used in the unparsed search string
|
|
terms = [
|
|
{operator: "stream", operand: "Foo"},
|
|
{operator: "subject", operand: "Bar"},
|
|
];
|
|
string = "channel:Foo topic:Bar";
|
|
assert.deepEqual(Filter.unparse(terms), string);
|
|
});
|
|
|
|
test("describe", ({mock_template}) => {
|
|
let narrow;
|
|
let string;
|
|
mock_template("search_description.hbs", true, (_data, html) => html);
|
|
|
|
narrow = [{operator: "channels", operand: "public"}];
|
|
string = "channels public";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [{operator: "channels", operand: "public", negated: true}];
|
|
string = "exclude channels public";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "channel", operand: "devel"},
|
|
{operator: "is", operand: "starred"},
|
|
];
|
|
string = "channel devel, starred messages";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "channel", operand: "river"},
|
|
{operator: "is", operand: "unread"},
|
|
];
|
|
string = "channel river, unread messages";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "channel", operand: "devel"},
|
|
{operator: "topic", operand: "JS"},
|
|
];
|
|
string = "channel devel > JS";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "is", operand: "dm"},
|
|
{operator: "search", operand: "lunch"},
|
|
];
|
|
string = "direct messages, search for lunch";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [{operator: "id", operand: 99}];
|
|
string = "message ID 99";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [{operator: "in", operand: "home"}];
|
|
string = "messages in home";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [{operator: "is", operand: "mentioned"}];
|
|
string = "@-mentions";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [{operator: "is", operand: "alerted"}];
|
|
string = "alerted messages";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [{operator: "is", operand: "resolved"}];
|
|
string = "topics marked as resolved";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [{operator: "is", operand: "something_we_do_not_support"}];
|
|
string = "invalid something_we_do_not_support operand for is operator";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
// this should be unreachable, but just in case
|
|
narrow = [{operator: "bogus", operand: "foo"}];
|
|
string = "unknown operator";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "channel", operand: "devel"},
|
|
{operator: "topic", operand: "JS", negated: true},
|
|
];
|
|
string = "channel devel, exclude topic JS";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "is", operand: "dm"},
|
|
{operator: "search", operand: "lunch", negated: true},
|
|
];
|
|
string = "direct messages, exclude lunch";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "channel", operand: "devel"},
|
|
{operator: "is", operand: "starred", negated: true},
|
|
];
|
|
string = "channel devel, exclude starred messages";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "channel", operand: "devel"},
|
|
{operator: "has", operand: "image", negated: true},
|
|
];
|
|
string = "channel devel, exclude messages with one or more image";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "has", operand: "abc", negated: true},
|
|
{operator: "channel", operand: "devel"},
|
|
];
|
|
string = "invalid abc operand for has operator, channel devel";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [
|
|
{operator: "has", operand: "image", negated: true},
|
|
{operator: "channel", operand: "devel"},
|
|
];
|
|
string = "exclude messages with one or more image, channel devel";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
narrow = [];
|
|
string = "combined feed";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
|
|
// canonical version of the operator is used in description
|
|
narrow = [
|
|
{operator: "stream", operand: "devel"},
|
|
{operator: "subject", operand: "JS", negated: true},
|
|
];
|
|
string = "channel devel, exclude topic JS";
|
|
assert.equal(Filter.search_description_as_html(narrow), string);
|
|
});
|
|
|
|
test("can_bucket_by", () => {
|
|
let terms = [{operator: "channel", operand: "My channel"}];
|
|
let filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("channel"), true);
|
|
assert.equal(filter.can_bucket_by("channel", "topic"), false);
|
|
assert.equal(filter.can_bucket_by("dm"), false);
|
|
|
|
terms = [
|
|
// try a non-orthodox ordering
|
|
{operator: "topic", operand: "My topic"},
|
|
{operator: "channel", operand: "My channel"},
|
|
];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("channel"), true);
|
|
assert.equal(filter.can_bucket_by("channel", "topic"), true);
|
|
assert.equal(filter.can_bucket_by("dm"), false);
|
|
|
|
terms = [
|
|
{operator: "channel", operand: "My channel", negated: true},
|
|
{operator: "topic", operand: "My topic"},
|
|
];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("channel"), false);
|
|
assert.equal(filter.can_bucket_by("channel", "topic"), false);
|
|
assert.equal(filter.can_bucket_by("dm"), false);
|
|
|
|
terms = [{operator: "dm", operand: "foo@example.com", negated: true}];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("channel"), false);
|
|
assert.equal(filter.can_bucket_by("channel", "topic"), false);
|
|
assert.equal(filter.can_bucket_by("dm"), false);
|
|
|
|
terms = [{operator: "dm", operand: "foo@example.com,bar@example.com"}];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("channel"), false);
|
|
assert.equal(filter.can_bucket_by("channel", "topic"), false);
|
|
assert.equal(filter.can_bucket_by("dm"), true);
|
|
assert.equal(filter.can_bucket_by("is-mentioned"), false);
|
|
assert.equal(filter.can_bucket_by("is-dm"), false);
|
|
|
|
terms = [{operator: "is", operand: "dm"}];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("is-mentioned"), false);
|
|
assert.equal(filter.can_bucket_by("is-dm"), true);
|
|
|
|
terms = [{operator: "is", operand: "mentioned"}];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("is-mentioned"), true);
|
|
assert.equal(filter.can_bucket_by("is-dm"), false);
|
|
|
|
terms = [
|
|
{operator: "is", operand: "mentioned"},
|
|
{operator: "is", operand: "starred"},
|
|
];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("is-mentioned"), true);
|
|
assert.equal(filter.can_bucket_by("is-dm"), false);
|
|
|
|
// The call below returns false for somewhat arbitrary
|
|
// reasons -- we say is-dm has precedence over
|
|
// is-starred.
|
|
assert.equal(filter.can_bucket_by("is-starred"), false);
|
|
|
|
terms = [{operator: "is", operand: "mentioned", negated: true}];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("is-mentioned"), false);
|
|
assert.equal(filter.can_bucket_by("is-dm"), false);
|
|
|
|
terms = [{operator: "is", operand: "resolved"}];
|
|
filter = new Filter(terms);
|
|
assert.equal(filter.can_bucket_by("channel", "topic"), false);
|
|
assert.equal(filter.can_bucket_by("channel"), false);
|
|
assert.equal(filter.can_bucket_by("dm"), false);
|
|
assert.equal(filter.can_bucket_by("is-mentioned"), false);
|
|
assert.equal(filter.can_bucket_by("is-dm"), false);
|
|
});
|
|
|
|
test("term_type", () => {
|
|
function assert_term_type(term, expected_term_type) {
|
|
assert.equal(Filter.term_type(term), expected_term_type);
|
|
}
|
|
|
|
function term(operator, operand, negated) {
|
|
return {
|
|
operator,
|
|
operand,
|
|
negated,
|
|
};
|
|
}
|
|
|
|
assert_term_type(term("channels", "public"), "channels-public");
|
|
assert_term_type(term("channel", "whatever"), "channel");
|
|
assert_term_type(term("dm", "whomever"), "dm");
|
|
assert_term_type(term("dm", "whomever", true), "not-dm");
|
|
assert_term_type(term("is", "dm"), "is-dm");
|
|
assert_term_type(term("is", "private"), "is-private");
|
|
assert_term_type(term("has", "link"), "has-link");
|
|
assert_term_type(term("has", "attachment", true), "not-has-attachment");
|
|
|
|
function assert_term_sort(in_terms, expected) {
|
|
const sorted_terms = Filter.sorted_term_types(in_terms);
|
|
assert.deepEqual(sorted_terms, expected);
|
|
}
|
|
|
|
assert_term_sort(["topic", "channel", "sender"], ["channel", "topic", "sender"]);
|
|
|
|
assert_term_sort(
|
|
["has-link", "near", "is-unread", "dm"],
|
|
["dm", "near", "is-unread", "has-link"],
|
|
);
|
|
|
|
assert_term_sort(["bogus", "channel", "topic"], ["channel", "topic", "bogus"]);
|
|
assert_term_sort(["channel", "topic", "channel"], ["channel", "channel", "topic"]);
|
|
|
|
assert_term_sort(["search", "channels-public"], ["channels-public", "search"]);
|
|
|
|
const terms = [
|
|
{operator: "topic", operand: "lunch"},
|
|
{operator: "sender", operand: "steve@foo.com"},
|
|
{operator: "channel", operand: "Verona"},
|
|
];
|
|
let filter = new Filter(terms);
|
|
const term_types = filter.sorted_term_types();
|
|
|
|
assert.deepEqual(term_types, ["channel", "topic", "sender"]);
|
|
|
|
// test caching of term types
|
|
// init and stub
|
|
filter = new Filter(terms);
|
|
filter.stub = filter._build_sorted_term_types;
|
|
filter._build_sorted_term_types = function () {
|
|
this._build_sorted_term_types_called = true;
|
|
return this.stub();
|
|
};
|
|
|
|
// uncached trial
|
|
filter._build_sorted_term_types_called = false;
|
|
const built_terms = filter.sorted_term_types();
|
|
assert.deepEqual(built_terms, ["channel", "topic", "sender"]);
|
|
assert.ok(filter._build_sorted_term_types_called);
|
|
|
|
// cached trial
|
|
filter._build_sorted_term_types_called = false;
|
|
const cached_terms = filter.sorted_term_types();
|
|
assert.deepEqual(cached_terms, ["channel", "topic", "sender"]);
|
|
assert.ok(!filter._build_sorted_term_types_called);
|
|
});
|
|
|
|
test("first_valid_id_from", ({override}) => {
|
|
const terms = [{operator: "is", operand: "alerted"}];
|
|
|
|
const filter = new Filter(terms);
|
|
|
|
const messages = {
|
|
5: {id: 5, alerted: true},
|
|
10: {id: 10},
|
|
20: {id: 20, alerted: true},
|
|
30: {id: 30, type: stream_message},
|
|
40: {id: 40, alerted: false},
|
|
};
|
|
|
|
const msg_ids = [10, 20, 30, 40];
|
|
|
|
override(message_store, "get", (msg_id) => messages[msg_id]);
|
|
|
|
assert.equal(filter.first_valid_id_from([999]), undefined);
|
|
|
|
assert.equal(filter.first_valid_id_from(msg_ids), 20);
|
|
});
|
|
|
|
test("update_email", () => {
|
|
const terms = [
|
|
{operator: "dm", operand: "steve@foo.com"},
|
|
{operator: "sender", operand: "steve@foo.com"},
|
|
{operator: "channel", operand: "steve@foo.com"}, // try to be tricky
|
|
];
|
|
const filter = new Filter(terms);
|
|
filter.update_email(steve.user_id, "showell@foo.com");
|
|
assert.deepEqual(filter.operands("dm"), ["showell@foo.com"]);
|
|
assert.deepEqual(filter.operands("sender"), ["showell@foo.com"]);
|
|
assert.deepEqual(filter.operands("channel"), ["steve@foo.com"]);
|
|
});
|
|
|
|
function make_private_sub(name, stream_id) {
|
|
const sub = {
|
|
name,
|
|
stream_id,
|
|
invite_only: true,
|
|
};
|
|
stream_data.add_sub(sub);
|
|
}
|
|
|
|
function make_web_public_sub(name, stream_id) {
|
|
const sub = {
|
|
name,
|
|
stream_id,
|
|
is_web_public: true,
|
|
};
|
|
stream_data.add_sub(sub);
|
|
}
|
|
|
|
test("navbar_helpers", () => {
|
|
const stream_id = 43;
|
|
make_sub("Foo", stream_id);
|
|
|
|
// make sure title has names separated with correct delimiters
|
|
function properly_separated_names(names) {
|
|
const names_internationalized = new Intl.ListFormat("en", {
|
|
style: "long",
|
|
type: "conjunction",
|
|
}).format(names);
|
|
return names_internationalized;
|
|
}
|
|
|
|
function test_redirect_url_with_search(test_case) {
|
|
const terms = [...test_case.terms, {operator: "search", operand: "fizzbuzz"}];
|
|
const filter = new Filter(terms);
|
|
assert.equal(filter.generate_redirect_url(), test_case.redirect_url_with_search);
|
|
}
|
|
|
|
function test_common_narrow(test_case) {
|
|
const filter = new Filter(test_case.terms);
|
|
assert.equal(filter.is_common_narrow(), test_case.is_common_narrow);
|
|
}
|
|
|
|
function test_add_icon_data(test_case) {
|
|
const filter = new Filter(test_case.terms);
|
|
let context = {};
|
|
context = filter.add_icon_data(context);
|
|
assert.equal(context.icon, test_case.icon);
|
|
assert.equal(context.zulip_icon, test_case.zulip_icon);
|
|
}
|
|
|
|
function test_get_title(test_case) {
|
|
const filter = new Filter(test_case.terms);
|
|
assert.deepEqual(filter.get_title(), test_case.title);
|
|
}
|
|
|
|
function test_helpers(test_case) {
|
|
// debugging tip: add a `console.log(test_case)` here
|
|
test_common_narrow(test_case);
|
|
test_add_icon_data(test_case);
|
|
test_get_title(test_case);
|
|
test_redirect_url_with_search(test_case);
|
|
}
|
|
|
|
const sender = [{operator: "sender", operand: joe.email}];
|
|
const guest_sender = [{operator: "sender", operand: alice.email}];
|
|
const in_home = [{operator: "in", operand: "home"}];
|
|
const in_all = [{operator: "in", operand: "all"}];
|
|
const is_starred = [{operator: "is", operand: "starred"}];
|
|
const is_dm = [{operator: "is", operand: "dm"}];
|
|
const is_mentioned = [{operator: "is", operand: "mentioned"}];
|
|
const is_resolved = [{operator: "is", operand: "resolved"}];
|
|
const channels_public = [{operator: "channels", operand: "public"}];
|
|
const channel_topic_terms = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
];
|
|
// foo channel exists
|
|
const channel_term = [{operator: "channel", operand: "foo"}];
|
|
make_private_sub("psub", "22");
|
|
const private_channel_term = [{operator: "channel", operand: "psub"}];
|
|
make_web_public_sub("webPublicSub", "12"); // capitalized just to try be tricky and robust.
|
|
const web_public_channel = [{operator: "channel", operand: "webPublicSub"}];
|
|
const non_existent_channel = [{operator: "channel", operand: "Elephant"}];
|
|
const non_existent_channel_topic = [
|
|
{operator: "channel", operand: "Elephant"},
|
|
{operator: "topic", operand: "pink"},
|
|
];
|
|
const dm = [{operator: "dm", operand: "joe@example.com"}];
|
|
const dm_group = [{operator: "dm", operand: "joe@example.com,STEVE@foo.com"}];
|
|
const dm_with_guest = [{operator: "dm", operand: "alice@example.com"}];
|
|
const dm_group_including_guest = [
|
|
{operator: "dm", operand: "alice@example.com,joe@example.com"},
|
|
];
|
|
const dm_group_including_missing_person = [
|
|
{operator: "dm", operand: "joe@example.com,STEVE@foo.com,sally@doesnotexist.com"},
|
|
];
|
|
// not common narrows, but used for browser title updates
|
|
const is_alerted = [{operator: "is", operand: "alerted"}];
|
|
const is_unread = [{operator: "is", operand: "unread"}];
|
|
const channel_topic_near = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
{operator: "near", operand: "12"},
|
|
];
|
|
const dm_near = [
|
|
{operator: "dm", operand: "joe@example.com"},
|
|
{operator: "near", operand: "12"},
|
|
];
|
|
|
|
const test_cases = [
|
|
{
|
|
terms: sender,
|
|
is_common_narrow: true,
|
|
icon: undefined,
|
|
title: "translated: Messages sent by " + joe.full_name,
|
|
redirect_url_with_search: "/#narrow/sender/" + joe.user_id + "-joe",
|
|
},
|
|
{
|
|
terms: guest_sender,
|
|
is_common_narrow: true,
|
|
icon: undefined,
|
|
title: "translated: Messages sent by translated: alice (guest)",
|
|
redirect_url_with_search: "/#narrow/sender/" + alice.user_id + "-alice",
|
|
},
|
|
{
|
|
terms: is_starred,
|
|
is_common_narrow: true,
|
|
zulip_icon: "star-filled",
|
|
title: "translated: Starred messages",
|
|
redirect_url_with_search: "/#narrow/is/starred",
|
|
},
|
|
{
|
|
terms: in_home,
|
|
is_common_narrow: true,
|
|
icon: "home",
|
|
title: "translated: Combined feed",
|
|
redirect_url_with_search: "#",
|
|
},
|
|
{
|
|
terms: in_all,
|
|
is_common_narrow: true,
|
|
icon: "home",
|
|
title: "translated: All messages including muted channels",
|
|
redirect_url_with_search: "#",
|
|
},
|
|
{
|
|
terms: is_dm,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: "translated: Direct message feed",
|
|
redirect_url_with_search: "/#narrow/is/dm",
|
|
},
|
|
{
|
|
terms: is_mentioned,
|
|
is_common_narrow: true,
|
|
zulip_icon: "at-sign",
|
|
title: "translated: Mentions",
|
|
redirect_url_with_search: "/#narrow/is/mentioned",
|
|
},
|
|
{
|
|
terms: is_resolved,
|
|
is_common_narrow: true,
|
|
icon: "check",
|
|
title: "translated: Topics marked as resolved",
|
|
redirect_url_with_search: "/#narrow/topics/is/resolved",
|
|
},
|
|
{
|
|
terms: channel_topic_terms,
|
|
is_common_narrow: true,
|
|
zulip_icon: "hashtag",
|
|
title: "Foo",
|
|
redirect_url_with_search: "/#narrow/stream/43-Foo/topic/bar",
|
|
},
|
|
{
|
|
terms: channels_public,
|
|
is_common_narrow: true,
|
|
icon: undefined,
|
|
title: "translated: Messages in all public channels",
|
|
redirect_url_with_search: "/#narrow/streams/public",
|
|
},
|
|
{
|
|
terms: channel_term,
|
|
is_common_narrow: true,
|
|
zulip_icon: "hashtag",
|
|
title: "Foo",
|
|
redirect_url_with_search: "/#narrow/stream/43-Foo",
|
|
},
|
|
{
|
|
terms: non_existent_channel,
|
|
is_common_narrow: true,
|
|
icon: "question-circle-o",
|
|
title: "translated: Unknown channel #Elephant",
|
|
redirect_url_with_search: "#",
|
|
},
|
|
{
|
|
terms: non_existent_channel_topic,
|
|
is_common_narrow: true,
|
|
icon: "question-circle-o",
|
|
title: "translated: Unknown channel #Elephant",
|
|
redirect_url_with_search: "#",
|
|
},
|
|
{
|
|
terms: private_channel_term,
|
|
is_common_narrow: true,
|
|
zulip_icon: "lock",
|
|
title: "psub",
|
|
redirect_url_with_search: "/#narrow/stream/22-psub",
|
|
},
|
|
{
|
|
terms: web_public_channel,
|
|
is_common_narrow: true,
|
|
zulip_icon: "globe",
|
|
title: "webPublicSub",
|
|
redirect_url_with_search: "/#narrow/stream/12-webPublicSub",
|
|
},
|
|
{
|
|
terms: dm,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: properly_separated_names([joe.full_name]),
|
|
redirect_url_with_search:
|
|
"/#narrow/dm/" + joe.user_id + "-" + parseOneAddress(joe.email).local,
|
|
},
|
|
{
|
|
terms: dm_group,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: properly_separated_names([joe.full_name, steve.full_name]),
|
|
redirect_url_with_search: "/#narrow/dm/" + joe.user_id + "," + steve.user_id + "-group",
|
|
},
|
|
{
|
|
terms: dm_with_guest,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: "translated: alice (guest)",
|
|
redirect_url_with_search:
|
|
"/#narrow/dm/" + alice.user_id + "-" + parseOneAddress(alice.email).local,
|
|
},
|
|
{
|
|
terms: dm_group_including_guest,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: "translated: alice (guest) and joe",
|
|
redirect_url_with_search: "/#narrow/dm/" + joe.user_id + "," + alice.user_id + "-group",
|
|
},
|
|
{
|
|
terms: dm_group_including_missing_person,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: properly_separated_names([
|
|
joe.full_name,
|
|
steve.full_name,
|
|
"sally@doesnotexist.com",
|
|
]),
|
|
redirect_url_with_search: "/#narrow/dm/undefined",
|
|
},
|
|
{
|
|
terms: is_alerted,
|
|
is_common_narrow: false,
|
|
icon: undefined,
|
|
title: "translated: Alerted messages",
|
|
redirect_url_with_search: "#",
|
|
},
|
|
{
|
|
terms: is_unread,
|
|
is_common_narrow: false,
|
|
icon: undefined,
|
|
title: "translated: Unread messages",
|
|
redirect_url_with_search: "#",
|
|
},
|
|
{
|
|
terms: channel_topic_near,
|
|
is_common_narrow: false,
|
|
zulip_icon: "hashtag",
|
|
title: "Foo",
|
|
redirect_url_with_search: "#",
|
|
},
|
|
{
|
|
terms: dm_near,
|
|
is_common_narrow: false,
|
|
icon: "envelope",
|
|
title: properly_separated_names([joe.full_name]),
|
|
redirect_url_with_search: "#",
|
|
},
|
|
];
|
|
|
|
realm.realm_enable_guest_user_indicator = true;
|
|
|
|
for (const test_case of test_cases) {
|
|
test_helpers(test_case);
|
|
}
|
|
|
|
// TODO: these may be removed, based on design decisions
|
|
const sender_me = [{operator: "sender", operand: "me"}];
|
|
const sender_joe = [{operator: "sender", operand: joe.email}];
|
|
|
|
const redirect_edge_cases = [
|
|
{
|
|
terms: sender_me,
|
|
redirect_url_with_search: "/#narrow/sender/" + me.user_id + "-Me-Myself",
|
|
is_common_narrow: true,
|
|
},
|
|
{
|
|
terms: sender_joe,
|
|
redirect_url_with_search: "/#narrow/sender/" + joe.user_id + "-joe",
|
|
is_common_narrow: true,
|
|
},
|
|
];
|
|
|
|
for (const test_case of redirect_edge_cases) {
|
|
test_redirect_url_with_search(test_case);
|
|
}
|
|
|
|
// TODO: test every single one of the "ALL" redirects from the navbar behaviour table
|
|
|
|
// incomplete and weak test cases just to restore coverage of filter.ts
|
|
const complex_term = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
{operator: "sender", operand: "me"},
|
|
];
|
|
|
|
const redirect_url = "#";
|
|
|
|
let filter = new Filter(complex_term);
|
|
assert.equal(filter.generate_redirect_url(), redirect_url);
|
|
assert.equal(filter.is_common_narrow(), false);
|
|
|
|
const channel_topic_search_term = [
|
|
{operator: "channel", operand: "foo"},
|
|
{operator: "topic", operand: "bar"},
|
|
{operator: "search", operand: "potato"},
|
|
];
|
|
|
|
const channel_topic_search_term_test_case = {
|
|
terms: channel_topic_search_term,
|
|
title: undefined,
|
|
};
|
|
|
|
test_get_title(channel_topic_search_term_test_case);
|
|
|
|
realm.realm_enable_guest_user_indicator = false;
|
|
const guest_user_test_cases_without_indicator = [
|
|
{
|
|
terms: guest_sender,
|
|
is_common_narrow: true,
|
|
icon: undefined,
|
|
title: "translated: Messages sent by alice",
|
|
redirect_url_with_search: "/#narrow/sender/" + alice.user_id + "-alice",
|
|
},
|
|
{
|
|
terms: dm_with_guest,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: properly_separated_names([alice.full_name]),
|
|
redirect_url_with_search:
|
|
"/#narrow/dm/" + alice.user_id + "-" + parseOneAddress(alice.email).local,
|
|
},
|
|
{
|
|
terms: dm_group_including_guest,
|
|
is_common_narrow: true,
|
|
icon: "envelope",
|
|
title: properly_separated_names([alice.full_name, joe.full_name]),
|
|
redirect_url_with_search: "/#narrow/dm/" + joe.user_id + "," + alice.user_id + "-group",
|
|
},
|
|
];
|
|
|
|
for (const test_case of guest_user_test_cases_without_indicator) {
|
|
test_helpers(test_case);
|
|
}
|
|
|
|
// this is actually wrong, but the code is currently not robust enough to throw an error here
|
|
// also, used as an example of triggering last return statement.
|
|
const default_redirect = {
|
|
terms: [{operator: "channel", operand: "foo"}],
|
|
redirect_url: "#",
|
|
};
|
|
|
|
filter = new Filter(default_redirect.terms);
|
|
assert.equal(filter.generate_redirect_url(), default_redirect.redirect_url);
|
|
});
|
|
|
|
test("error_cases", () => {
|
|
// This test just gives us 100% line coverage on defensive code that
|
|
// should not be reached unless we break other code.
|
|
|
|
const predicate = get_predicate([["dm", "Joe@example.com"]]);
|
|
blueslip.expect("error", "Empty recipient list in message");
|
|
assert.ok(!predicate({type: direct_message, display_recipient: []}));
|
|
});
|
|
|
|
run_test("is_spectator_compatible", () => {
|
|
// tests same as test_is_spectator_compatible from test_message_fetch.py
|
|
assert.ok(Filter.is_spectator_compatible([]));
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "has", operand: "attachment"}]));
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "has", operand: "image"}]));
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "search", operand: "magic"}]));
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "near", operand: "15"}]));
|
|
assert.ok(
|
|
Filter.is_spectator_compatible([
|
|
{operator: "id", operand: "15"},
|
|
{operator: "has", operand: "attachment"},
|
|
]),
|
|
);
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "sender", operand: "hamlet@zulip.com"}]));
|
|
assert.ok(!Filter.is_spectator_compatible([{operator: "dm", operand: "hamlet@zulip.com"}]));
|
|
assert.ok(
|
|
!Filter.is_spectator_compatible([{operator: "dm-including", operand: "hamlet@zulip.com"}]),
|
|
);
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "channel", operand: "Denmark"}]));
|
|
assert.ok(
|
|
Filter.is_spectator_compatible([
|
|
{operator: "channel", operand: "Denmark"},
|
|
{operator: "topic", operand: "logic"},
|
|
]),
|
|
);
|
|
assert.ok(!Filter.is_spectator_compatible([{operator: "is", operand: "starred"}]));
|
|
assert.ok(!Filter.is_spectator_compatible([{operator: "is", operand: "dm"}]));
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "channels", operand: "public"}]));
|
|
|
|
// Malformed input not allowed
|
|
assert.ok(!Filter.is_spectator_compatible([{operator: "has"}]));
|
|
|
|
// "is:private" was renamed to "is:dm"
|
|
assert.ok(!Filter.is_spectator_compatible([{operator: "is", operand: "private"}]));
|
|
// "pm-with" was renamed to "dm"
|
|
assert.ok(
|
|
!Filter.is_spectator_compatible([{operator: "pm-with", operand: "hamlet@zulip.com"}]),
|
|
);
|
|
// "stream" was renamted to "channel"
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "stream", operand: "Denmark"}]));
|
|
// "streams" was renamed to "channels"
|
|
assert.ok(Filter.is_spectator_compatible([{operator: "streams", operand: "public"}]));
|
|
// "group-pm-with:" was replaced with "dm-including:"
|
|
assert.ok(
|
|
!Filter.is_spectator_compatible([{operator: "group-pm-with", operand: "hamlet@zulip.com"}]),
|
|
);
|
|
});
|
|
|
|
run_test("is_in_home", () => {
|
|
const filter = new Filter([{operator: "in", operand: "home"}]);
|
|
assert.ok(filter.is_in_home());
|
|
|
|
const filter2 = new Filter([{operator: "in", operand: "all"}]);
|
|
assert.ok(!filter2.is_in_home());
|
|
|
|
// Test home with additional terms is not all messages.
|
|
const filter3 = new Filter([
|
|
{operator: "in", operand: "home"},
|
|
{operator: "topic", operand: "foo"},
|
|
]);
|
|
assert.ok(!filter3.is_in_home());
|
|
});
|