"use strict"; const assert = require("node:assert/strict"); const {parseOneAddress} = require("email-addresses"); const {make_realm} = require("./lib/example_realm.cjs"); const {make_stream} = require("./lib/example_stream.cjs"); const {make_user, Role} = require("./lib/example_user.cjs"); const {mock_esm, with_overrides, zrequire, clock} = require("./lib/namespace.cjs"); const {run_test} = require("./lib/test.cjs"); const blueslip = require("./lib/zblueslip.cjs"); const {$} = require("./lib/zjquery.cjs"); const {page_params} = require("./lib/zpage_params.cjs"); const message_store = zrequire("message_store"); const user_topics = mock_esm("../src/user_topics"); const resolved_topic = zrequire("resolved_topic"); const stream_data = zrequire("stream_data"); const people = zrequire("people"); const {Filter} = zrequire("filter"); const filter_util = zrequire("filter_util"); const {set_current_user, set_realm} = zrequire("state_data"); const {initialize_user_settings} = zrequire("user_settings"); const muted_users = zrequire("muted_users"); const state_data = zrequire("state_data"); const realm = make_realm(); set_realm(realm); const current_user = {}; set_current_user(current_user); initialize_user_settings({user_settings: {}}); const stream_message = "stream"; const direct_message = "private"; const me = make_user({ email: "me@example.com", user_id: 30, full_name: "Me Myself", }); const joe = make_user({ email: "joe@example.com", user_id: 31, full_name: "joe", }); const steve = make_user({ email: "STEVE@foo.com", user_id: 32, full_name: "steve", }); const alice = make_user({ email: "alice@example.com", user_id: 33, full_name: "alice", role: Role.GUEST, }); const jeff = make_user({ email: "jeff@foo.com", user_id: 34, full_name: "jeff", }); const annie = make_user({ email: "annie@foo.com", user_id: 35, full_name: "annie", role: Role.GUEST, }); // Multi-word names, to exercise resolving typed full names to user ids. const karl = make_user({ email: "karl@foo.com", user_id: 36, full_name: "Karl Stolley", }); const shubham = make_user({ email: "shubham@foo.com", user_id: 37, full_name: "Shubham Padia", }); // Two users sharing a full name, to exercise duplicate-name handling. const sam_one = make_user({ email: "sam1@foo.com", user_id: 38, full_name: "Sam Park", }); const sam_two = make_user({ email: "sam2@foo.com", user_id: 39, full_name: "Sam Park", }); // Add users to `valid_user_ids`. const source = "server_events"; people.add_active_user(me, source); people.add_active_user(joe, source); people.add_active_user(steve, source); people.add_active_user(alice, source); people.add_active_user(jeff, source); people.add_active_user(annie, source); people.add_active_user(karl, source); people.add_active_user(shubham, source); people.add_active_user(sam_one, source); people.add_active_user(sam_two, source); people.initialize_current_user(me.user_id); state_data.set_current_user(me); muted_users.add_muted_user(jeff.user_id); muted_users.add_muted_user(annie.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 = make_stream({ name, stream_id, }); stream_data.add_sub_for_tests(sub); } let _stream_id = 0; function new_stream_id() { _stream_id += 1; return _stream_id; } const foo_stream_id = new_stream_id(); const foo_sub = make_stream({ name: "Foo", stream_id: foo_stream_id, }); const general_sub = make_stream({ name: "general", stream_id: new_stream_id(), }); stream_data.add_sub_for_tests(general_sub); const invalid_sub_id = new_stream_id(); function test(label, f) { run_test(label, (helpers) => { stream_data.clear_subscriptions(); f(helpers); }); } test("basics", () => { let terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "channel", operand: invalid_sub_id.toString(), negated: true}, // excluded {operator: "topic", operand: "bar"}, ]; let filter = new Filter(terms); assert_same_terms(filter.terms(), terms); let channel_terms = filter.terms_with_operator("channel"); assert.deepEqual(channel_terms, [ {operator: "channel", operand: foo_stream_id.toString(), negated: false}, ]); assert.ok(filter.has_operator("channel")); assert.ok(!filter.has_operator("search")); assert.ok(filter.has_operand("channel", foo_stream_id.toString())); assert.ok(!filter.has_operand("channel", invalid_sub_id.toString())); assert.ok(!filter.is_keyword_search()); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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.is_channel_view()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.can_show_next_unread_topic_conversation_button()); assert.ok(!filter.can_show_next_unread_dm_conversation_button()); assert.ok(filter.can_bucket_by("channel")); assert.ok(filter.can_bucket_by("channel", "topic")); assert.ok(!filter.has_exactly_channel_topic_operators()); // "stream" was renamed to "channel" terms = [{operator: "stream", operand: foo_stream_id.toString()}]; filter = new Filter(terms); assert.ok(filter.has_operator("channel")); channel_terms = filter.terms_with_operator("channel"); assert.deepEqual(channel_terms, [ {operator: "channel", operand: foo_stream_id.toString(), negated: false}, ]); assert.ok(filter.includes_full_stream_history()); assert.ok(filter.can_apply_locally()); assert.ok(filter.can_show_next_unread_topic_conversation_button()); assert.ok(!filter.can_show_next_unread_dm_conversation_button()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "channel", operand: invalid_sub_id.toString(), negated: true}, // excluded {operator: "topic", operand: "bar"}, ]; filter = new Filter(terms); channel_terms = filter.terms_with_operator("channel"); assert.deepEqual(channel_terms, [ {operator: "channel", operand: foo_stream_id.toString(), negated: false}, ]); assert.ok(filter.has_operator("channel")); assert.ok(!filter.has_operator("search")); assert.ok(filter.has_operand("channel", foo_stream_id.toString())); assert.ok(!filter.has_operand("channel", invalid_sub_id.toString())); assert.ok(!filter.is_keyword_search()); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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.is_channel_view()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {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.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {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.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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()); assert.ok(!filter.is_channel_view()); assert.ok(filter.is_conversation_view_with_near()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(filter.can_show_next_unread_topic_conversation_button()); assert.ok(!filter.can_show_next_unread_dm_conversation_button()); assert.ok(!filter.has_exactly_channel_topic_operators()); // 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: invalid_sub_id.toString(), negated: true}]; filter = new Filter(terms); assert.ok(filter.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(!filter.has_operator("channel")); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); // 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.may_have_incomplete_message_history()); 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.contains_no_partial_conversations()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.can_show_next_unread_topic_conversation_button()); assert.ok(!filter.can_show_next_unread_dm_conversation_button()); assert.ok(!filter.has_exactly_channel_topic_operators()); // 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.contains_no_partial_conversations()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "channels", operand: "public", negated: true}]; filter = new Filter(terms); assert.ok(filter.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(!filter.has_operator("channels")); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); 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()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "channels", operand: "public"}]; filter = new Filter(terms); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(filter.has_operator("channels")); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); 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()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "channels", operand: "archived", 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.contains_no_partial_conversations()); assert.ok(filter.has_negated_operand("channels", "archived")); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "channels", operand: "archived"}]; 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.contains_no_partial_conversations()); assert.ok(!filter.has_negated_operand("channels", "archived")); 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()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.has_exactly_channel_topic_operators()); // "streams" was renamed to "channels" terms = [{operator: "streams", operand: "public"}]; filter = new Filter(terms); assert.ok(filter.has_operator("channels")); assert.ok(filter.contains_no_partial_conversations()); assert.ok(filter.includes_full_stream_history()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "is", operand: "dm"}]; filter = new Filter(terms); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(filter.contains_only_private_messages()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.has_operator("search")); assert.ok(filter.can_apply_locally()); assert.ok(filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.can_show_next_unread_topic_conversation_button()); assert.ok(filter.can_show_next_unread_dm_conversation_button()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "is", operand: "dm", negated: true}]; filter = new Filter(terms); assert.ok(filter.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.has_operator("search")); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(!filter.is_channel_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.can_show_next_unread_topic_conversation_button()); assert.ok(!filter.can_show_next_unread_dm_conversation_button()); assert.ok(!filter.has_exactly_channel_topic_operators()); // "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")); assert.ok(!filter.can_show_next_unread_topic_conversation_button()); assert.ok(filter.can_show_next_unread_dm_conversation_button()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "is", operand: "mentioned"}]; filter = new Filter(terms); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(!filter.can_mark_messages_read()); assert.ok(!filter.contains_no_partial_conversations()); assert.ok(!filter.has_operator("search")); assert.ok(filter.can_apply_locally()); assert.ok(filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.can_show_next_unread_topic_conversation_button()); assert.ok(!filter.can_show_next_unread_dm_conversation_button()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "is", operand: "starred"}]; filter = new Filter(terms); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(!filter.can_mark_messages_read()); assert.ok(!filter.contains_no_partial_conversations()); assert.ok(!filter.has_operator("search")); assert.ok(filter.can_apply_locally()); assert.ok(filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "dm", operand: [joe.user_id]}]; filter = new Filter(terms); assert.ok(filter.is_search_for_specific_group_or_user()); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(filter.contains_only_private_messages()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.has_operator("search")); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(filter.is_conversation_view()); assert.ok(!filter.is_conversation_view_with_near()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [ {operator: "dm", operand: [joe.user_id]}, {operator: "near", operand: "17"}, ]; filter = new Filter(terms); assert.ok(filter.is_search_for_specific_group_or_user()); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(filter.contains_only_private_messages()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.has_operator("search")); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(filter.is_conversation_view()); assert.ok(filter.is_conversation_view_with_near()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "dm", operand: [joe.user_id, steve.user_id]}]; filter = new Filter(terms); assert.ok(filter.is_search_for_specific_group_or_user()); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(filter.contains_only_private_messages()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(filter.is_conversation_view()); assert.ok(!filter.is_conversation_view_with_near()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [ {operator: "dm", operand: [joe.user_id, steve.user_id]}, {operator: "with", operand: "12"}, ]; filter = new Filter(terms); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(filter.contains_only_private_messages()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(filter.is_conversation_view()); assert.ok(!filter.is_conversation_view_with_near()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); // "pm-with" was renamed to "dm" terms = [{operator: "pm-with", operand: [joe.user_id]}]; filter = new Filter(terms); assert.ok(filter.has_operator("dm")); assert.ok(!filter.has_operator(" pm-with")); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "dm-including", operand: [joe.user_id]}]; filter = new Filter(terms); assert.ok(filter.is_search_for_specific_group_or_user()); assert.ok(!filter.may_have_incomplete_message_history()); assert.ok(filter.contains_only_private_messages()); assert.ok(!filter.has_operator("search")); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); // "group-pm-with" was replaced with "dm-including" terms = [{operator: "group-pm-with", operand: [joe.user_id]}]; filter = new Filter(terms); assert.ok(filter.has_operator("dm-including")); assert.ok(!filter.has_operator("group-pm-with")); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [{operator: "is", operand: "resolved"}]; filter = new Filter(terms); assert.ok(filter.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(!filter.has_operator("search")); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); // Highly complex query to exercise // filter.contains_no_partial_conversations loop. terms = [ {operator: "is", operand: "resolved", negated: true}, {operator: "is", operand: "followed", 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.may_have_incomplete_message_history()); assert.ok(!filter.contains_only_private_messages()); assert.ok(!filter.has_operator("search")); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); // 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()); assert.ok(filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, ]; filter = new Filter(terms); assert.ok(!filter.is_keyword_search()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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.is_conversation_view_with_near()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(filter.has_exactly_channel_topic_operators()); terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, {operator: "with", operand: "17"}, ]; filter = new Filter(terms); assert.ok(!filter.is_keyword_search()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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", "topic", "with")); assert.ok(!filter.is_conversation_view_with_near()); assert.ok(!filter.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); // "stream" was renamed to "channel" terms = [ {operator: "stream", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, ]; filter = new Filter(terms); assert.ok(!filter.is_keyword_search()); assert.ok(filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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.is_conversation_view_with_near()); assert.ok(!filter.is_channel_view()); assert.ok(filter.has_exactly_channel_topic_operators()); terms = [ {operator: "channel", operand: "channel_name"}, {operator: "channels", operand: "public"}, {operator: "topic", operand: "patience"}, ]; filter = new Filter(terms); assert.ok(!filter.is_keyword_search()); assert.ok(!filter.can_mark_messages_read()); assert.ok(filter.contains_no_partial_conversations()); assert.ok(!filter.may_have_incomplete_message_history()); 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.may_contain_multiple_conversations()); assert.ok(!filter.is_channel_view()); assert.ok(!filter.has_exactly_channel_topic_operators()); terms = [ {operator: "channel", operand: "foo", negated: false}, {operator: "topic", operand: "bar", negated: false}, ]; filter = new Filter(terms); assert.equal(filter.has_exactly_channel_topic_operators(), true); filter.adjust_with_operand_to_message(12); assert.deepEqual(filter.terms(), [...terms, {operator: "with", operand: "12"}]); assert.equal(filter.has_exactly_channel_topic_operators(), false); terms = [{operator: "channel", operand: "foo", negated: false}]; filter = new Filter(terms); assert.ok(filter.is_channel_view()); terms = [{operator: "mentions", operand: joe.user_id}]; 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.contains_no_partial_conversations()); assert.ok(!filter.can_apply_locally()); assert.ok(!filter.is_personal_filter()); assert.ok(!filter.is_conversation_view()); assert.ok(!filter.is_channel_view()); // Throw error on invalid operator. assert.throws(() => get_predicate([["bogus", "33"]]), { name: "$ZodError", }); }); function assert_not_mark_read_with_has_operands(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()); has_link_term = [{operator: "has", operand: "reaction"}]; 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 ||= []; 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()); is_operator = [{operator: "is", operand: "followed", 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 ||= []; 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_stream_id.toString()}]; 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_stream_id.toString(), negated: true}, ]; filter = new Filter(channel_negated_operator); assert.ok(!filter.can_mark_messages_read()); const channel_topic_terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {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_stream_id.toString()}, {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.user_id]}]; const dm_negated = [{operator: "dm", operand: [joe.user_id], negated: true}]; const dm_group = [{operator: "dm", operand: [joe.user_id, steve.user_id]}]; 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()); const is_muted = [{operator: "is", operand: "muted"}]; const is_muted_negated = [{operator: "is", operand: "muted", negated: true}]; filter = new Filter(is_muted); assert.ok(!filter.can_mark_messages_read()); assert_not_mark_read_with_is_operands(is_muted); assert_not_mark_read_with_has_operands(is_muted); assert_not_mark_read_when_searching(is_muted); filter = new Filter(is_muted_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()); terms = [{operator: "is", operand: "starred"}]; filter = new Filter(terms); 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_stream_id.toString()}, {operator: "topic", operand: "old topic"}, ]; const filter = new Filter(terms); assert.ok(filter.has_topic(foo_stream_id.toString(), "old topic")); assert.ok(!filter.has_topic(invalid_sub_id.toString(), "old topic")); assert.ok(!filter.has_topic(foo_stream_id.toString(), "wrong")); const new_filter = filter.filter_with_new_params({ operator: "topic", operand: "new topic", }); const channel_terms = new_filter.terms_with_operator("channel"); assert.deepEqual(channel_terms, [ {operator: "channel", operand: foo_stream_id.toString(), negated: false}, ]); const topic_terms = new_filter.terms_with_operator("topic"); assert.deepEqual(topic_terms, [{operator: "topic", operand: "new topic", negated: false}]); }); test("filter_with_new_params_channel", () => { const terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "old topic"}, ]; const filter = new Filter(terms); assert.ok(filter.has_topic(foo_stream_id.toString(), "old topic")); assert.ok(!filter.has_topic(invalid_sub_id.toString(), "old topic")); assert.ok(!filter.has_topic(foo_stream_id.toString(), "wrong")); const new_filter = filter.filter_with_new_params({ operator: "channel", operand: "new channel", }); const channel_terms = new_filter.terms_with_operator("channel"); assert.deepEqual(channel_terms, [ {operator: "channel", operand: "new channel", negated: false}, ]); const topic_terms = new_filter.terms_with_operator("topic"); assert.deepEqual(topic_terms, [{operator: "topic", operand: "old topic", negated: false}]); }); test("new_style_terms", () => { const term = { operator: "channel", operand: foo_stream_id.toString(), }; const terms = [term]; const filter = new Filter(terms); const channel_terms = filter.terms_with_operator("channel"); assert.deepEqual(channel_terms, [ {operator: "channel", operand: foo_stream_id.toString(), negated: false}, ]); assert.ok(filter.can_bucket_by("channel")); }); test("public_terms", ({override}) => { stream_data.clear_subscriptions(); const some_channel_id = new_stream_id(); const default_channel_id = new_stream_id(); make_sub("default", default_channel_id); let terms = [ {operator: "channel", operand: some_channel_id.toString()}, {operator: "in", operand: "all"}, {operator: "topic", operand: "bar"}, {operator: "date", operand: "2025-04-01"}, ]; let filter = new Filter(terms); const expected_terms = [ {operator: "channel", operand: some_channel_id.toString()}, {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_channel_id.toString()}]; 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.user_id]}, {operator: "is", operand: "dm"}, ]; filter = new Filter(terms); assert.ok(filter.can_bucket_by("dm")); terms = [ {operator: "dm", operand: [joe.user_id], 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_util.canonicalize_operator("is"), "is"); assert.equal(filter_util.canonicalize_operator("stream"), "channel"); assert.equal(filter_util.canonicalize_operator("subject"), "topic"); assert.equal(filter_util.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.convert_suggestion_to_term({operator: "sender", operand: "me"}); assert.equal(term.operator, "sender"); assert.equal(term.operand, me.user_id); // mentions:me redirects to is:mentioned term = Filter.convert_suggestion_to_term({operator: "mentions", operand: "me"}); assert.equal(term.operator, "is"); assert.equal(term.operand, "mentioned"); // "pm-with" was renamed to "dm" term = Filter.convert_suggestion_to_term({operator: "pm-with", operand: "me"}); assert.equal(term.operator, "dm"); assert.deepEqual(term.operand, [me.user_id]); // "group-pm-with" was replaced with "dm-including" term = Filter.canonicalize_term({operator: "group-pm-with", operand: [joe.user_id]}); assert.equal(term.operator, "dm-including"); assert.deepEqual(term.operand, [joe.user_id]); 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: "date", operand: "2022-06-10"}); assert.equal(term.operator, "date"); assert.equal(term.operand, "2022-06-10"); 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"); term = Filter.canonicalize_term({operator: "has", operand: "reactions"}); assert.equal(term.operator, "has"); assert.equal(term.operand, "reaction"); term = Filter.canonicalize_term({operator: "mentions", operand: joe.user_id}); assert.equal(term.operator, "mentions"); assert.equal(term.operand, joe.user_id); }); test("ensure_channel_topic_terms", () => { const channel_term = {operator: "channel", operand: `${general_sub.stream_id}`}; const topic_term = {operator: "topic", operand: "discussion"}; const message = { type: "stream", id: 12, stream_id: general_sub.stream_id, display_recipient: "general", topic: "discussion", }; const term_1 = Filter.ensure_channel_topic_terms( [{operator: "with", operand: message.id}], message, ); const term_2 = Filter.ensure_channel_topic_terms( [topic_term, {operator: "with", operand: message.id}], message, ); const term_3 = Filter.ensure_channel_topic_terms( [channel_term, {operator: "with", operand: message.id}], message, ); const term_4 = Filter.ensure_channel_topic_terms( [ {operator: "dm", operand: [joe.user_id]}, {operator: "with", operand: message.id}, ], message, ); const term_5 = Filter.ensure_channel_topic_terms( [{operator: "with", operand: message.id}], message, ); const terms = [term_1, term_2, term_3, term_4, term_5]; for (const term of terms) { assert.deepEqual(term, [channel_term, topic_term, {operator: "with", operand: 12}]); } }); test("predicate_basics", ({override}) => { // 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. stream_data.add_sub_for_tests(foo_sub); let predicate = get_predicate([ ["channel", foo_stream_id.toString()], ["topic", "Bar"], ]); assert.ok(predicate({type: stream_message, stream_id: foo_stream_id, topic: "bar"})); assert.ok(!predicate({type: stream_message, stream_id: foo_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})); // Three or more terms: channel + topic + is:starred. predicate = get_predicate([ ["channel", foo_stream_id.toString()], ["topic", "Bar"], ["is", "starred"], ]); assert.ok( predicate({type: stream_message, stream_id: foo_stream_id, topic: "bar", starred: true}), ); assert.ok( !predicate({type: stream_message, stream_id: foo_stream_id, topic: "bar", starred: false}), ); assert.ok( !predicate({ type: stream_message, stream_id: foo_stream_id, topic: "whatever", starred: true, }), ); assert.ok(!predicate({type: direct_message, starred: true})); // 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_id = new_stream_id(); const private_sub_id = new_stream_id(); const web_public_sub_id = new_stream_id(); const archived_sub_id = new_stream_id(); const old_sub = { name: "old-subscription", stream_id: old_sub_id, subscribed: false, invite_only: false, is_web_public: false, }; const private_sub = { name: "private-subscription", stream_id: private_sub_id, subscribed: true, invite_only: true, is_web_public: false, }; const web_public_sub = { name: "web-public-subscription", stream_id: web_public_sub_id, subscribed: false, invite_only: false, is_web_public: true, }; const archived_sub = { name: "archived-subscription", stream_id: archived_sub_id, subscribed: true, invite_only: false, is_web_public: true, is_archived: true, }; stream_data.add_sub_for_tests(old_sub); stream_data.add_sub_for_tests(private_sub); stream_data.add_sub_for_tests(web_public_sub); stream_data.add_sub_for_tests(archived_sub); predicate = get_predicate([ ["channel", old_sub_id.toString()], ["topic", "Bar"], ]); assert.ok(predicate({type: stream_message, stream_id: old_sub.stream_id, topic: "bar"})); // 99999 doesn't exist, testing no match assert.ok(!predicate({type: stream_message, stream_id: invalid_sub_id, 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({type: stream_message, stream_id: old_sub_id})); assert.ok(!predicate({type: stream_message, stream_id: private_sub_id})); assert.ok(predicate({type: stream_message, stream_id: web_public_sub_id})); predicate = get_predicate([["channels", "archived"]]); assert.ok(predicate({type: stream_message, stream_id: archived_sub_id})); predicate = get_predicate([["channels", "web-public"]]); assert.ok(predicate({type: stream_message, stream_id: archived_sub_id})); assert.ok(predicate({type: stream_message, stream_id: web_public_sub_id})); assert.ok(!predicate({type: stream_message, stream_id: old_sub_id})); predicate = get_predicate([["channels", "bogus"]]); assert.ok(!predicate({type: stream_message, stream_id: old_sub_id})); 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"})); predicate = get_predicate([["is", "followed"]]); override(user_topics, "is_topic_followed", () => false); assert.ok(!predicate({type: "stream", topic: "foo", stream_id: 5})); override(user_topics, "is_topic_followed", () => true); assert.ok(predicate({type: "stream", topic: "foo", stream_id: 5})); const unknown_stream_id = new_stream_id(); override(user_topics, "is_topic_visible_in_home", () => false); predicate = get_predicate([["in", "home"]]); assert.ok(!predicate({stream_id: unknown_stream_id, stream: "unknown"})); assert.ok(predicate({type: direct_message})); // Muted topic is not part of in-home. with_overrides(({override}) => { override(user_topics, "is_topic_visible_in_home", () => false); assert.ok(!predicate({stream_id: foo_stream_id, topic: "bar"})); }); // Muted stream is not part of in-home. const muted_stream = { stream_id: 94924, name: "muted", is_muted: true, }; stream_data.add_sub_for_tests(muted_stream); assert.ok(!predicate({stream_id: muted_stream.stream_id, topic: "bar"})); // Muted stream but topic is unmuted or followed is part of in-home. with_overrides(({override}) => { override(user_topics, "is_topic_visible_in_home", () => true); assert.ok(predicate({stream_id: muted_stream.stream_id, topic: "bar"})); }); make_sub("kiosk", 1234); with_overrides(({override}) => { override(page_params, "narrow_stream", "kiosk"); assert.ok(predicate({stream_id: 1234})); }); override(user_topics, "is_topic_visible_in_home", () => false); predicate = get_predicate([["is", "muted"]]); assert.ok(predicate({stream_id: unknown_stream_id, stream: "unknown"})); assert.ok(!predicate({type: direct_message})); // Muted topic is a part of is-muted. with_overrides(({override}) => { override(user_topics, "is_topic_visible_in_home", () => false); assert.ok(predicate({stream_id: foo_stream_id, topic: "bar"})); }); // Muted stream is a part of is:muted. assert.ok(predicate({stream_id: muted_stream.stream_id, topic: "bar"})); // Muted stream but topic is unmuted or followed is not a part of is-muted. with_overrides(({override}) => { override(user_topics, "is_topic_visible_in_home", () => true); assert.ok(!predicate({stream_id: muted_stream.stream_id, topic: "bar"})); }); 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.user_id]]); assert.ok(predicate({sender_id: joe.user_id})); assert.ok(!predicate({sender_email: steve.user_id})); predicate = get_predicate([["dm", [joe.user_id]]]); 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.user_id, steve.user_id]]]); assert.ok( predicate({ type: direct_message, display_recipient: [{id: joe.user_id}, {id: steve.user_id}], }), ); // A 1:1 DM message should not match a group DM predicate. assert.ok( !predicate({ type: direct_message, display_recipient: [{id: joe.user_id}], }), ); // Make sure your own user id is ignored predicate = get_predicate([["dm", [joe.user_id, steve.user_id, me.user_id]]]); assert.ok( predicate({ type: direct_message, display_recipient: [{id: joe.user_id}, {id: steve.user_id}], }), ); predicate = get_predicate([["dm", [1000]]]); assert.ok( !predicate({ type: direct_message, display_recipient: [{id: joe.user_id}], }), ); predicate = get_predicate([["dm-including", [1000]]]); assert.ok( !predicate({ type: direct_message, display_recipient: [{id: joe.user_id}, {id: me.user_id}], }), ); predicate = get_predicate([["dm-including", [joe.user_id]]]); 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 inline_audio_msg = { content: '

', }; predicate = get_predicate([["mentions", joe.user_id]]); assert.ok(predicate({})); const inline_img_msg = { content: '

Screenshot

', }; const img_msg = { // Even though the HTML class `message_inline_image` is modified // in post_process for rendered message, the raw content stays the same. content: '

test.jpeg

', }; const link_msg = { content: '

chat.zulip.org

', }; const non_img_attachment_msg = { content: '

attachment.ext

', }; const no_has_filter_matching_msg = { content: "

Testing

", }; const clean_reactions_message = { clean_reactions: new Map( Object.entries({ "unicode_emoji,1f3b1": { class: "message_reaction reacted", count: 2, emoji_alt_code: false, emoji_code: "1f3b1", emoji_name: "8ball", is_realm_emoji: false, label: "translated: You (click to remove) and Bob van Roberts reacted with :8ball:", local_id: "unicode_emoji,1f3b1", reaction_type: "unicode_emoji", user_ids: [alice.user_id], vote_text: "translated: You, Bob van Roberts", }, }), ), }; const non_reaction_msg = { clean_reactions: new Map(), }; predicate = get_predicate([["has", "non_valid_operand"]]); assert.ok(!predicate(inline_audio_msg)); assert.ok(!predicate(inline_img_msg)); 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) { $(`
${msg.content}
`).set_find_results(jquery_selector, results); } const has_link = get_predicate([["has", "link"]]); set_find_results_for_msg_content(inline_audio_msg, "a", []); assert.ok(!has_link(inline_audio_msg)); set_find_results_for_msg_content(inline_img_msg, "a", []); assert.ok(!has_link(inline_img_msg)); 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", []); assert.ok(!has_link(no_has_filter_matching_msg)); const has_attachment = get_predicate([["has", "attachment"]]); const attachment_selector_string = "a[href^='/user_uploads'], img[src^='/user_uploads'], audio[src^='/user_uploads']"; set_find_results_for_msg_content(inline_audio_msg, attachment_selector_string, ["stub"]); assert.ok(has_attachment(inline_audio_msg)); set_find_results_for_msg_content(inline_img_msg, attachment_selector_string, ["stub"]); assert.ok(has_attachment(inline_img_msg)); set_find_results_for_msg_content(img_msg, attachment_selector_string, ["stub"]); assert.ok(has_attachment(img_msg)); set_find_results_for_msg_content(non_img_attachment_msg, attachment_selector_string, ["stub"]); assert.ok(has_attachment(non_img_attachment_msg)); set_find_results_for_msg_content(link_msg, attachment_selector_string, []); assert.ok(!has_attachment(link_msg)); set_find_results_for_msg_content(no_has_filter_matching_msg, attachment_selector_string, []); assert.ok(!has_attachment(no_has_filter_matching_msg)); const has_image = get_predicate([["has", "image"]]); const image_selector_string = ".message_inline_image, .inline-image"; set_find_results_for_msg_content(inline_audio_msg, image_selector_string, []); assert.ok(!has_image(inline_audio_msg)); set_find_results_for_msg_content(inline_img_msg, image_selector_string, ["stub"]); assert.ok(has_image(inline_img_msg)); set_find_results_for_msg_content(img_msg, image_selector_string, ["stub"]); assert.ok(has_image(img_msg)); set_find_results_for_msg_content(non_img_attachment_msg, image_selector_string, []); assert.ok(!has_image(non_img_attachment_msg)); set_find_results_for_msg_content(link_msg, image_selector_string, []); assert.ok(!has_image(link_msg)); set_find_results_for_msg_content(no_has_filter_matching_msg, image_selector_string, []); assert.ok(!has_image(no_has_filter_matching_msg)); const has_reaction = get_predicate([["has", "reaction"]]); assert.ok(has_reaction(clean_reactions_message)); assert.ok(!has_reaction(non_reaction_msg)); }); test("negated_predicates", () => { let predicate; let narrow; const social_stream_id = new_stream_id(); make_sub("social", social_stream_id); narrow = [{operator: "channel", operand: social_stream_id.toString(), 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({})); }); 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([["is", "bogus"]]); assert.ok(!predicate({})); // Exercise caching feature. const stream_id = new_stream_id(); make_sub("Off topic", stream_id); const terms = [ {operator: "channel", operand: stream_id.toString()}, {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(for_pills = false) { const result = Filter.parse(string, for_pills); assert_same_terms(result, terms); } make_sub(foo_sub.name, foo_stream_id); string = "channel:Foo topic:bar yo"; terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, {operator: "search", operand: "yo"}, ]; _test(); // A digit-leading channel name resolves by name, not by reading // its leading digits as a stream id. make_sub("7th", 7000); string = "channel:7th"; terms = [{operator: "channel", operand: "7000"}]; _test(); // A digit-leading operand with no matching channel is left as-is, // not coerced into a stream id. string = "channel:9th"; terms = [{operator: "channel", operand: "9th"}]; _test(); string = `channel:${foo_stream_id} topic:bar yo`; terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, {operator: "search", operand: "yo"}, ]; _test(); // "stream" was renamed to "channel" string = `stream:${foo_stream_id} topic:Bar yo`; terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {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 = "sender:me"; terms = [{operator: "sender", operand: `${me.user_id}`}]; _test(true); string = "-sender:me"; terms = [{operator: "sender", operand: `${me.user_id}`, negated: true}]; _test(true); string = "mentions:me"; terms = [{operator: "is", operand: "mentioned"}]; _test(true); string = "-mentions:me"; terms = [{operator: "is", operand: "mentioned", negated: true}]; _test(true); string = "https://www.google.com"; terms = [{operator: "search", operand: "https://www.google.com"}]; _test(); string = `channel:${foo_stream_id} -channel:${invalid_sub_id}`; terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "channel", operand: invalid_sub_id.toString(), negated: true}, ]; _test(); string = `text channel:${foo_stream_id} more text`; terms = [ {operator: "search", operand: "text"}, {operator: "channel", operand: foo_stream_id.toString()}, {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: "channels", operand: "public"}]; _test(); string = `channel:${foo_stream_id} :emoji: are cool`; terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "search", operand: ":emoji: are cool"}, ]; _test(); string = `:channel: channel:${foo_stream_id} :emoji: are cool`; terms = [ {operator: "search", operand: ":channel:"}, {operator: "channel", operand: foo_stream_id.toString()}, {operator: "search", operand: ":emoji: are cool"}, ]; _test(); string = `:channel: channel:${foo_stream_id} -:emoji: are cool`; terms = [ {operator: "search", operand: ":channel:"}, {operator: "channel", operand: foo_stream_id.toString()}, {operator: "search", operand: "-:emoji: are cool"}, ]; _test(); string = ""; terms = []; _test(); string = `channel: ${foo_stream_id} topic: "separated with space"`; terms = [ {operator: "channel", operand: ""}, {operator: "search", operand: foo_stream_id.toString()}, {operator: "topic", operand: ""}, {operator: "search", operand: '"separated with space"'}, ]; _test(); string = `topic: is:starred`; terms = [ {operator: "topic", operand: ""}, {operator: "is", operand: "starred"}, ]; _test(); string = "https://www.google.com"; terms = [{operator: "search", operand: "https://www.google.com"}]; _test(); string = "date:a week ago"; terms = [ {operator: "date", operand: "a"}, {operator: "search", operand: "week ago"}, ]; _test(); string = "date:2025-03-12 hello"; terms = [ {operator: "date", operand: "2025-03-12"}, {operator: "search", operand: "hello"}, ]; _test(); }); test("unparse", () => { let string; let terms; terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "Bar", negated: true}, {operator: "search", operand: "yo"}, ]; string = `channel:${foo_stream_id} -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_stream_id.toString()}, {operator: "subject", operand: "Bar"}, ]; string = `channel:${foo_stream_id} topic:Bar`; assert.deepEqual(Filter.unparse(terms), string); terms = [{operator: "topic", operand: '\t "%+.\u{A0}'}]; string = "topic:%09+%22%25%2B.%C2%A0"; assert.equal(Filter.unparse(terms), string); assert_same_terms(Filter.parse(string), terms); }); test("describe", ({mock_template, override}) => { let narrow; let string; let terms; mock_template("search_description.hbs", true, (_data, html) => html); narrow = [{operator: "channels", operand: "public"}]; string = "all public channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "channels", operand: "public", negated: true}]; string = "exclude all public channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "channels", operand: "archived"}]; string = "archived channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "channels", operand: "archived", negated: true}]; string = "exclude archived channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "channels", operand: "web-public"}]; string = "all web-public channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "channels", operand: "web-public", negated: true}]; string = "exclude all web-public channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); page_params.is_spectator = true; narrow = [{operator: "channels", operand: "public"}]; string = "all public channels that you can view"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "channels", operand: "web-public"}]; string = "all web-public channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "channels", operand: "web-public", negated: true}]; string = "exclude all web-public channels"; assert.equal(Filter.search_description_as_html(narrow, false), string); page_params.is_spectator = false; narrow = [{operator: "date", operand: ""}]; string = "messages sent around a specific date"; assert.equal(Filter.search_description_as_html(narrow, true), string); narrow = [{operator: "date", operand: "2026-03-15"}]; string = "messages sent around March 15, 2026"; assert.equal(Filter.search_description_as_html(narrow, false), string); const devel_decorated = `devel`; const river_decorated = `river`; const devel_id = new_stream_id(); make_sub("devel", devel_id); narrow = [ {operator: "channel", operand: devel_id.toString()}, {operator: "is", operand: "starred"}, ]; string = `messages in ${devel_decorated}, starred messages`; assert.equal(Filter.search_description_as_html(narrow, false), string); const river_id = new_stream_id(); make_sub("river", river_id); narrow = [ {operator: "channel", operand: river_id.toString()}, {operator: "is", operand: "unread"}, ]; string = `messages in ${river_decorated}, unread messages`; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "channel", operand: devel_id.toString()}, {operator: "topic", operand: "JS"}, ]; string = `messages in ${devel_decorated} > JS`; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "is", operand: "dm"}, {operator: "search", operand: "lunch"}, ]; string = "direct messages, search for lunch"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "id", operand: "99"}]; string = "message ID 99"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "in", operand: "home"}]; string = "messages in home"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "is", operand: "mentioned"}]; string = "messages that mention you"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "is", operand: "alerted"}]; string = "alerted messages"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "is", operand: "resolved"}]; string = "resolved topics"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "is", operand: "followed"}]; string = "followed topics"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "is", operand: "muted"}]; string = "muted messages"; assert.equal(Filter.search_description_as_html(narrow, false), string); // operands with their own negative words, like resolved. narrow = [{operator: "is", operand: "resolved", negated: true}]; string = "unresolved topics"; assert.equal(Filter.search_description_as_html(narrow, false), 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, false), string); // All the `is` operands are handled in search_suggestions. This is just // for coverage. assert.equal(Filter.operator_to_prefix("is"), "messages that are"); narrow = [{operator: "with", operand: "12"}]; string = "unknown operator"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "channel", operand: devel_id.toString()}, {operator: "topic", operand: "JS", negated: true}, ]; string = `messages in ${devel_decorated}, exclude topic JS`; assert.equal(Filter.search_description_as_html(narrow, false), 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, false), string); narrow = [ {operator: "channel", operand: devel_id.toString()}, {operator: "is", operand: "starred", negated: true}, ]; string = `messages in ${devel_decorated}, exclude starred messages`; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "channel", operand: devel_id.toString()}, {operator: "has", operand: "image", negated: true}, ]; string = `messages in ${devel_decorated}, exclude messages with images`; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "has", operand: "abc", negated: true}, {operator: "channel", operand: devel_id.toString()}, ]; string = `invalid abc operand for has operator, messages in ${devel_decorated}`; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "has", operand: "image", negated: true}, {operator: "channel", operand: devel_id.toString()}, ]; string = `exclude messages with images, messages in ${devel_decorated}`; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = []; string = "combined feed"; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "channel", operand: devel_id.toString()}, {operator: "subject", operand: "JS", negated: true}, ]; string = `messages in ${devel_decorated}, exclude topic JS`; assert.equal(Filter.search_description_as_html(narrow, false), string); // Empty string topic involved. override(realm, "realm_empty_topic_display_name", "general chat"); narrow = [ {operator: "channel", operand: devel_id.toString()}, {operator: "topic", operand: ""}, ]; string = `messages in ${devel_decorated} > translated: general chat`; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [ {operator: "topic", operand: ""}, {operator: "is", operand: "starred"}, ]; string = 'topic translated: general chat, starred messages'; assert.equal(Filter.search_description_as_html(narrow, false), string); narrow = [{operator: "topic", operand: ""}]; string = `topic translated: general chat`; assert.equal(Filter.search_description_as_html(narrow, false), string); /* Description for operator suggestion search terms */ terms = [{operator: "channels", operand: ""}]; string = "channel type"; assert.equal(Filter.search_description_as_html(terms, true), string); terms = [{operator: "topic", operand: ""}]; string = "topic"; assert.equal(Filter.search_description_as_html(terms, true), string); terms = [{operator: "near", operand: ""}]; string = "messages around"; assert.equal(Filter.search_description_as_html(terms, true), string); terms = [{operator: "sender", operand: ""}]; string = "sent by"; assert.equal(Filter.search_description_as_html(terms, true), string); terms = [{operator: "dm-including", operand: ""}]; string = "direct messages including"; assert.equal(Filter.search_description_as_html(terms, true), string); terms = [{operator: "mentions", operand: ""}]; string = "messages mentioning"; assert.equal(Filter.search_description_as_html(terms, true), string); }); test("can_bucket_by", () => { const channel_id = new_stream_id(); make_sub("My channel", channel_id); let terms = [{operator: "channel", operand: channel_id.toString()}]; 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: channel_id.toString()}, ]; 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: channel_id.toString(), 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: [steve.user_id], 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); assert.equal(filter.can_bucket_by("dm", "with"), false); terms = [{operator: "dm", operand: [steve.user_id, joe.user_id]}]; 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("dm", "with"), false); assert.equal(filter.can_bucket_by("is-mentioned"), false); assert.equal(filter.can_bucket_by("is-dm"), false); terms = [ {operator: "dm", operand: [steve.user_id, joe.user_id]}, {operator: "with", operand: "7"}, ]; 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", "with"), 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(["topic", "channel", "with"], ["channel", "topic", "with"]); 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.user_id}, {operator: "channel", operand: new_stream_id().toString()}, ]; 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", () => { const terms = [{operator: "is", operand: "alerted"}]; const filter = new Filter(terms); const messages = [ { message: { id: 5, alerted: true, }, }, { message: { id: 12, }, }, { message: {id: 20, alerted: true}, }, { message: {id: 30, type: stream_message}, }, { message: {id: 40, alerted: false}, }, ]; message_store.set_messages_for_tests(messages); const msg_ids = [10, 20, 30, 40]; assert.equal(filter.first_valid_id_from([999]), undefined); assert.equal(filter.first_valid_id_from(msg_ids), 20); }); test("convert_suggestion_to_term", () => { const denmark = { stream_id: 100, name: "Denmark", }; stream_data.add_sub_for_tests(denmark); const test_data = [ ["has:image", true], ["has:nonsense", false], ["is:unread", true], ["is:nonsense", false], ["in:home", true], ["in:nowhere", false], ["id:4", true], ["-id:4", false], ["near:1", true], ["-near:1", false], ["with:1", true], ["-with:1", false], ["near:home", false], ["channel:" + denmark.stream_id, true], [`channel:${invalid_sub_id}`, false], ["channels:public", true], ["channels:private", false], ["topic:GhostTown", true], [`dm-including:${alice.user_id}`, true], ["sender:-1", false], ["sender:me", true], [`dm:${[alice.user_id, -1]}`, false], [`dm:${[alice.user_id, joe.user_id]}`, true], [`mentions:${alice.user_id}`, true], ["mentions:me", true], ["mentions:-1", false], ["mentions:invalid", false], // A typed full name resolves to a user id, matching the help center // docs. Quotes keep a multi-word name a single operand through the // parser. A third tuple element pins down the resolved term, so a // name maps to the right user id and not merely to some valid term. [`sender:"${karl.full_name}"`, true, {operator: "sender", operand: karl.user_id}], [`mentions:"${karl.full_name}"`, true, {operator: "mentions", operand: karl.user_id}], // dm and dm-including resolve a comma-separated list of names to the // corresponding user ids. [`dm:"${karl.full_name}"`, true, {operator: "dm", operand: [karl.user_id]}], [ `dm:"${karl.full_name}, ${shubham.full_name}"`, true, {operator: "dm", operand: [karl.user_id, shubham.user_id]}, ], [ `dm-including:"${karl.full_name}, ${shubham.full_name}"`, true, {operator: "dm-including", operand: [karl.user_id, shubham.user_id]}, ], // A name that matches no user is invalid. ['dm:"No Such Person"', false], // An ambiguous (duplicate) full name is invalid on its own... [`dm:"${sam_one.full_name}"`, false], // ...but the `Full Name|user_id` form disambiguates it, resolving to // exactly the requested user and not the other duplicate. [ `dm:"${sam_one.full_name}|${sam_one.user_id}"`, true, {operator: "dm", operand: [sam_one.user_id]}, ], [ `dm:"${sam_two.full_name}|${sam_two.user_id}"`, true, {operator: "dm", operand: [sam_two.user_id]}, ], [`-date:2022-01-01`, false], [`date:2022-01-01`, true], // Not a valid date string. [`date:2022-01-01abcd`, false], // In the past [`date:1500-01-06`, false], // Not in the `yyyy-MM-dd` format [`date:2020-`, false], ]; const today = new Date(2024, 0, 15, 2, 0, 0); clock.setSystemTime(today.getTime()); for (const [search_term_string, expected_is_valid, expected_term] of test_data) { const term = Filter.convert_suggestion_to_term(Filter.parse(search_term_string)[0]); assert.equal(term !== undefined, expected_is_valid); if (expected_term !== undefined) { assert.deepEqual(term, {negated: false, ...expected_term}); } } clock.reset(); // Invalid operator. assert.equal( Filter.convert_suggestion_to_term({ operator: "foo", operand: "bar", }) !== undefined, false, ); }); test("try_adjusting_for_moved_with_target", () => { const scotland_id = new_stream_id(); make_sub("Scotland", scotland_id); const verona_id = new_stream_id(); make_sub("Verona", verona_id); const messages = [ { message: { type: "stream", stream_id: scotland_id, display_recipient: "Scotland", topic: "Test 1", id: 12, }, }, { message: { type: "stream", stream_id: verona_id, display_recipient: "Verona", topic: "Test 2", id: 17, }, }, { message: { type: "direct", id: 2, display_recipient: [{id: 3, email: "user3@zulip.com"}], }, }, ]; message_store.set_messages_for_tests(messages); // When the narrow terms are correct, it returns the same terms let terms = [ {operator: "channel", operand: scotland_id.toString(), negated: false}, {operator: "topic", operand: "Test 1", negated: false}, {operator: "with", operand: "12", negated: false}, ]; let filter = new Filter(terms); assert.deepEqual(filter.requires_adjustment_for_moved_with_target, true); filter.try_adjusting_for_moved_with_target(); assert.deepEqual(filter.requires_adjustment_for_moved_with_target, false); assert.deepEqual(filter.terms(), terms); // When the narrow terms are incorrect, the narrow is corrected // to the narrow of the `with` operand. const incorrect_terms = [ {operator: "channel", operand: verona_id.toString(), negated: false}, {operator: "topic", operand: "Test 2", negated: false}, {operator: "with", operand: "12", negated: false}, ]; filter = new Filter(incorrect_terms); assert.deepEqual(filter.requires_adjustment_for_moved_with_target, true); filter.try_adjusting_for_moved_with_target(); assert.deepEqual(filter.requires_adjustment_for_moved_with_target, false); assert.deepEqual(filter.terms(), terms); // when message specified in `with` operator does not exist in // message_store, we rather go to the server, without any updates. terms = [ {operator: "channel", operand: scotland_id.toString(), negated: false}, {operator: "topic", operand: "Test 1", negated: false}, {operator: "with", operand: "11", negated: false}, ]; filter = new Filter(terms); filter.try_adjusting_for_moved_with_target(); assert.deepEqual(filter.requires_adjustment_for_moved_with_target, true); assert.deepEqual(filter.terms(), terms); // When the narrow consists of `channel` or `topic` operators, while // the `with` operator corresponds to that of a direct message, then // the narrow is adjusted to point to the narrow containing the message. terms = [ {operator: "channel", operand: scotland_id.toString(), negated: false}, {operator: "topic", operand: "Test 1", negated: false}, {operator: "with", operand: "2", negated: false}, ]; filter = new Filter(terms); filter.try_adjusting_for_moved_with_target(); assert.deepEqual(filter.requires_adjustment_for_moved_with_target, false); assert.deepEqual(filter.terms(), [ {operator: "dm", operand: [3], negated: false}, {operator: "with", operand: "2", negated: false}, ]); // When the narrow consists of `dm` operators, while the `with` // operator corresponds to that of a channel topic message. terms = [ {operator: "dm", operand: [alice.user_id]}, {operator: "with", operand: "12"}, ]; filter = new Filter(terms); filter.try_adjusting_for_moved_with_target(); assert.deepEqual(filter.requires_adjustment_for_moved_with_target, false); assert.deepEqual(filter.terms(), [ {operator: "channel", operand: scotland_id.toString(), negated: false}, {operator: "topic", operand: "Test 1", negated: false}, {operator: "with", operand: "12", negated: false}, ]); // When message id attached to `with` operator is found locally, // and is present in the same narrow as the original one, then // no hash change is required. terms = [ {operator: "channel", operand: verona_id.toString(), negated: false}, {operator: "topic", operand: "Test 2", negated: false}, {operator: "with", operand: "17", negated: false}, ]; filter = new Filter(terms); filter.try_adjusting_for_moved_with_target(); assert.deepEqual(filter.narrow_requires_hash_change, false); // When message id attached to `with` operator is not found // locally, but messages fetched are in same narrow as // original narrow, then no hash change is required. terms = [ {operator: "channel", operand: verona_id.toString(), negated: false}, {operator: "topic", operand: "Test 2", negated: false}, {operator: "with", operand: "1", negated: false}, ]; filter = new Filter(terms); filter.try_adjusting_for_moved_with_target(); // now messages are fetched from server, and a single // fetched message is used to adjust narrow terms. filter.try_adjusting_for_moved_with_target(message_store.get(17)); assert.deepEqual(filter.narrow_requires_hash_change, false); // When message id attached to `with` operator is found locally, // and is not present in the same narrow as the original one, // then hash change is required. terms = [ {operator: "channel", operand: verona_id.toString(), negated: false}, {operator: "topic", operand: "Test 2", negated: false}, {operator: "with", operand: "12", negated: false}, ]; filter = new Filter(terms); filter.try_adjusting_for_moved_with_target(); assert.deepEqual(filter.narrow_requires_hash_change, true); // When message id attached to `with` operator is not found // locally, and messages fetched are in different narrow from // original narrow, then hash change is required. terms = [ {operator: "channel", operand: verona_id.toString(), negated: false}, {operator: "topic", operand: "Test 2", negated: false}, {operator: "with", operand: "1", negated: false}, ]; filter = new Filter(terms); filter.try_adjusting_for_moved_with_target(); // now messages are fetched from server, and a single // fetched message is used to adjust narrow terms. filter.try_adjusting_for_moved_with_target(message_store.get(12)); assert.deepEqual(filter.narrow_requires_hash_change, true); }); function make_private_sub(name, stream_id) { const sub = { name, stream_id, invite_only: true, }; stream_data.add_sub_for_tests(sub); } function make_web_public_sub(name, stream_id) { const sub = { name, stream_id, is_web_public: true, }; stream_data.add_sub_for_tests(sub); } function make_archived_sub(name, stream_id) { const sub = { name, stream_id, is_archived: true, }; stream_data.add_sub_for_tests(sub); } test("navbar_helpers", ({override}) => { stream_data.add_sub_for_tests(foo_sub); // 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_get_description(test_case) { const filter = new Filter(test_case.terms); const description = filter.get_description(); if (test_case.description !== undefined && test_case.link !== undefined) { assert.deepEqual(description, { description: test_case.description, link: test_case.link, }); } else { assert.strictEqual(description, undefined); } } 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_get_description(test_case); test_redirect_url_with_search(test_case); } const sender = [{operator: "sender", operand: joe.user_id}]; const guest_sender = [{operator: "sender", operand: alice.user_id}]; const invalid_sender = [{operator: "sender", operand: 9999}]; 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 not_is_dm = [{operator: "is", operand: "dm", negated: true}]; const is_mentioned = [{operator: "is", operand: "mentioned"}]; const is_resolved = [{operator: "is", operand: "resolved"}]; const is_followed = [{operator: "is", operand: "followed"}]; const channels_public = [{operator: "channels", operand: "public"}]; const channels_archived = [{operator: "channels", operand: "archived"}]; const not_channels_archived = [{operator: "channels", operand: "archived", negated: true}]; const channels_web_public = [{operator: "channels", operand: "web-public"}]; const channel_topic_terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, ]; const has_reaction_sender_me = [ {operator: "has", operand: "reaction"}, {operator: "sender", operand: me.user_id}, ]; // foo channel exists const channel_term = [{operator: "channel", operand: foo_stream_id.toString()}]; const invalid_channel_id = new_stream_id(); const invalid_channel = [{operator: "channel", operand: invalid_channel_id.toString()}]; const invalid_channel_with_topic = [ {operator: "channel", operand: invalid_channel_id.toString()}, {operator: "topic", operand: "bar"}, ]; // channel/topic name using special character for url encoding. const special_sub_id = new_stream_id(); make_sub("Foo2.0", special_sub_id); const char_channel_term = [{operator: "channel", operand: special_sub_id.toString()}]; const char_channel_topic_term = [ {operator: "channel", operand: special_sub_id.toString()}, {operator: "topic", operand: "bar2.0"}, ]; const public_sub_id = new_stream_id(); make_private_sub("psub", public_sub_id); const private_channel_term = [{operator: "channel", operand: public_sub_id.toString()}]; const web_public_sub_id = new_stream_id(); make_web_public_sub("webPublicSub", web_public_sub_id); // capitalized just to try be tricky and robust. const web_public_channel = [{operator: "channel", operand: web_public_sub_id.toString()}]; const archived_sub_id = new_stream_id(); make_archived_sub("archivedSub", archived_sub_id); const archived_channel_term = [{operator: "channel", operand: archived_sub_id.toString()}]; const dm = [{operator: "dm", operand: [joe.user_id]}]; const dm_with = [ {operator: "dm", operand: [joe.user_id]}, {operator: "with", operand: "12"}, ]; const dm_with_self = [{operator: "dm", operand: [me.user_id]}]; const dm_group = [{operator: "dm", operand: [joe.user_id, steve.user_id]}]; const dm_with_guest = [{operator: "dm", operand: [alice.user_id]}]; const dm_with_muted_user = [{operator: "dm", operand: [jeff.user_id]}]; const dm_with_muted_guest_user = [{operator: "dm", operand: [annie.user_id]}]; const dm_group_including_guest = [{operator: "dm", operand: [joe.user_id, alice.user_id]}]; const dm_group_including_muted_user = [{operator: "dm", operand: [joe.user_id, jeff.user_id]}]; const dm_group_including_muted_guest_user = [ {operator: "dm", operand: [joe.user_id, annie.user_id]}, ]; const dm_group_including_missing_person = [{operator: "dm", operand: [9999, joe.user_id]}]; // 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_stream_id.toString()}, {operator: "topic", operand: "bar"}, {operator: "near", operand: "12"}, ]; const dm_near = [ {operator: "dm", operand: [joe.user_id]}, {operator: "near", operand: "12"}, ]; const channel_with = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, {operator: "with", 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: invalid_sender, is_common_narrow: true, icon: undefined, title: "translated: Messages sent by unknown user", redirect_url_with_search: "/#narrow/sender/undefined", }, { terms: is_starred, is_common_narrow: true, zulip_icon: "star", title: "translated: Starred messages", redirect_url_with_search: "/#narrow/is/starred", description: "translated: Important messages, tasks, and other useful references.", link: "/help/star-a-message#view-your-starred-messages", }, { 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, zulip_icon: "user", title: "translated: Direct message feed", redirect_url_with_search: "/#narrow/is/dm", }, { terms: not_is_dm, is_common_narrow: true, zulip_icon: "hashtag", title: "translated: Channel messages", 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", description: "translated: Messages where you are mentioned.", link: "/help/view-your-mentions", }, { terms: is_resolved, is_common_narrow: true, icon: "check", title: "translated: Resolved topics", redirect_url_with_search: "/#narrow/topics/is/resolved", }, { terms: is_followed, is_common_narrow: true, zulip_icon: "follow", title: "translated: Followed topics", redirect_url_with_search: "/#narrow/topics/is/followed", description: "translated: Messages in topics you follow.", link: "/help/follow-a-topic", }, { terms: channel_topic_terms, is_common_narrow: true, zulip_icon: "hashtag", title: "Foo", redirect_url_with_search: `/#narrow/channel/${foo_stream_id}-Foo/topic/bar`, }, { terms: char_channel_term, is_common_narrow: true, zulip_icon: "hashtag", title: "Foo2.0", redirect_url_with_search: `/#narrow/channel/${special_sub_id}-Foo2.2E0`, }, { terms: char_channel_topic_term, is_common_narrow: true, zulip_icon: "hashtag", title: "Foo2.0", redirect_url_with_search: `/#narrow/channel/${special_sub_id}-Foo2.2E0/topic/bar2.2E0`, }, { terms: invalid_channel_with_topic, is_common_narrow: true, icon: "question-circle-o", title: "translated: Unknown channel", redirect_url_with_search: "#", }, { terms: channels_public, is_common_narrow: true, icon: undefined, title: "translated: Messages in all public channels", redirect_url_with_search: "/#narrow/channels/public", }, { terms: channels_archived, is_common_narrow: true, icon: undefined, title: "translated: Messages in your archived channels", redirect_url_with_search: "/#narrow/channels/archived", }, { terms: not_channels_archived, is_common_narrow: true, icon: undefined, title: "translated: Messages not in archived channels", redirect_url_with_search: "/#narrow/-channels/archived", }, { terms: channels_web_public, is_common_narrow: true, icon: undefined, title: "translated: Messages in all web-public channels", redirect_url_with_search: "/#narrow/channels/web-public", }, { terms: channel_term, is_common_narrow: true, zulip_icon: "hashtag", title: "Foo", redirect_url_with_search: `/#narrow/channel/${foo_stream_id}-Foo`, }, { terms: invalid_channel, is_common_narrow: true, icon: "question-circle-o", title: "translated: Unknown channel", redirect_url_with_search: "#", }, { terms: private_channel_term, is_common_narrow: true, zulip_icon: "lock", title: "psub", redirect_url_with_search: `/#narrow/channel/${public_sub_id}-psub`, }, { terms: web_public_channel, is_common_narrow: true, zulip_icon: "globe", title: "webPublicSub", redirect_url_with_search: `/#narrow/channel/${web_public_sub_id}-webPublicSub`, }, { terms: archived_channel_term, is_common_narrow: true, zulip_icon: "archive", title: "archivedSub", redirect_url_with_search: `/#narrow/channel/${archived_sub_id}-archivedSub`, }, { terms: dm, is_common_narrow: true, zulip_icon: "user", 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, zulip_icon: "user", 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_muted_user, is_common_narrow: true, zulip_icon: "user", title: "translated: Muted user", redirect_url_with_search: "/#narrow/dm/" + jeff.user_id + "-" + jeff.full_name, }, { terms: dm_with_muted_guest_user, is_common_narrow: true, zulip_icon: "user", title: "translated: Muted user (guest)", redirect_url_with_search: "/#narrow/dm/" + annie.user_id + "-" + annie.full_name, }, { terms: dm_with_guest, is_common_narrow: true, zulip_icon: "user", 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, zulip_icon: "user", title: "joe and translated: alice (guest)", redirect_url_with_search: "/#narrow/dm/" + joe.user_id + "," + alice.user_id + "-group", }, { terms: dm_group_including_muted_user, is_common_narrow: true, zulip_icon: "user", title: "joe and translated: Muted user", redirect_url_with_search: "/#narrow/dm/" + joe.user_id + "," + jeff.user_id + "-group", }, { terms: dm_group_including_muted_guest_user, is_common_narrow: true, zulip_icon: "user", title: "joe and translated: Muted user (guest)", redirect_url_with_search: "/#narrow/dm/" + joe.user_id + "," + annie.user_id + "-group", }, { terms: dm_group_including_missing_person, is_common_narrow: true, zulip_icon: "user", title: "joe and translated: Unknown user (9999)", redirect_url_with_search: "/#narrow/dm/undefined", }, { terms: has_reaction_sender_me, is_common_narrow: true, zulip_icon: "smile", title: "translated: Reactions", redirect_url_with_search: "/#narrow/has/reaction/sender/me", description: "translated: Emoji reactions to your messages.", link: "/help/emoji-reactions", }, { 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, zulip_icon: "user", title: properly_separated_names([joe.full_name]), redirect_url_with_search: "#", }, { terms: channel_with, is_common_narrow: true, zulip_icon: "hashtag", title: "Foo", redirect_url_with_search: "#", }, { terms: dm_with, is_common_narrow: true, zulip_icon: "user", title: properly_separated_names([joe.full_name]), redirect_url_with_search: "#", }, { terms: dm_with_self, is_common_narrow: true, zulip_icon: "user", title: "translated: Messages with yourself", redirect_url_with_search: "/#narrow/dm/30-Me-Myself", }, ]; override(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.user_id}]; const sender_joe = [{operator: "sender", operand: joe.user_id}]; 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_stream_id.toString()}, {operator: "topic", operand: "bar"}, {operator: "sender", operand: me.user_id}, ]; 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_stream_id.toString()}, {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); page_params.is_spectator = true; const channels_public_search_test_case_for_spectator = { terms: channels_public, title: "translated: Messages in all public channels that you can view", }; test_get_title(channels_public_search_test_case_for_spectator); page_params.is_spectator = false; override(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, zulip_icon: "user", 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, zulip_icon: "user", 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_stream_id.toString()}], 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.user_id]]]); 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: "is", operand: "resolved"}])); assert.ok( Filter.is_spectator_compatible([{operator: "is", operand: "resolved", negated: true}]), ); 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"}]), ); const denmark_id = new_stream_id(); make_sub("Denmark", denmark_id); assert.ok( Filter.is_spectator_compatible([{operator: "channel", operand: denmark_id.toString()}]), ); assert.ok( Filter.is_spectator_compatible([ {operator: "channel", operand: denmark_id.toString()}, {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"}])); assert.ok(Filter.is_spectator_compatible([{operator: "channels", operand: "archived"}])); // 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"}]), ); assert.ok( !Filter.is_spectator_compatible([{operator: "mentions", 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()); }); run_test("excludes_muted_topics", () => { let filter = new Filter([{operator: "is", operand: "starred"}]); assert.ok(!filter.excludes_muted_topics()); filter = new Filter([{operator: "is", operand: "muted"}]); assert.ok(!filter.excludes_muted_topics()); filter = new Filter([{operator: "in", operand: "home", negated: true}]); assert.ok(!filter.excludes_muted_topics()); filter = new Filter([{operator: "search", operand: "pizza"}]); assert.ok(!filter.excludes_muted_topics()); filter = new Filter([ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "bar"}, ]); assert.ok(!filter.excludes_muted_topics()); filter = new Filter([{operator: "is", operand: "dm"}]); assert.ok(!filter.excludes_muted_topics()); }); run_test("equals", () => { let terms = [{operator: "channel", operand: foo_stream_id.toString()}]; let filter = new Filter(terms); assert.ok(filter.equals(new Filter(terms))); assert.ok(!filter.equals(new Filter([]))); assert.ok(!filter.equals(new Filter([{operand: "Bar", operator: "channel"}]))); assert.ok(!filter.equals(new Filter([...terms, {operator: "topic", operand: "Bar"}]))); terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "topic", operand: "Bar"}, ]; filter = new Filter(terms); assert.ok( filter.equals( new Filter([ {operator: "topic", operand: "Bar"}, {operator: "channel", operand: foo_stream_id.toString()}, ]), ), ); assert.ok(!filter.equals(new Filter([...terms, {operator: "near", operand: "10"}]))); // Exclude `near` operator from comparison. assert.ok(filter.equals(new Filter([...terms, {operator: "near", operand: "10"}]), ["near"])); assert.ok( filter.equals( new Filter([ {operator: "near", operand: "10"}, {operator: "topic", operand: "Bar"}, {operator: "channel", operand: foo_stream_id.toString()}, {operator: "near", operand: "101"}, ]), ["near"], ), ); }); run_test("adjusted_terms_if_moved", ({override}) => { override(current_user, "email", me.email); // should return null for non-stream messages containing no // `with` operator let raw_terms = [{operator: "channel", operand: foo_stream_id.toString()}]; let message = {type: "private"}; let result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.strictEqual(result, null); // should adjust terms to contain `dm` for non-stream messages // if it contains `with` operator message = { type: "private", id: 2, display_recipient: [ {id: 3, email: "user3@zulip.com"}, {id: me.user_id, email: me.email}, ], }; raw_terms = [ {operator: "channel", operand: foo_stream_id.toString()}, {operator: "with", operand: `${message.id}`}, ]; result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.deepEqual(result, [ {operator: "dm", operand: [3], negated: false}, {operator: "with", operand: "2"}, ]); message = { type: "private", id: 2, display_recipient: [{id: me.user_id, email: me.email}], }; raw_terms = [ {operator: "channel", operand: "Foo"}, {operator: "with", operand: `${message.id}`}, ]; result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.deepEqual(result, [ {operator: "dm", operand: [me.user_id], negated: false}, {operator: "with", operand: "2"}, ]); // should return null if no terms are changed raw_terms = [{operator: "channel", operand: general_sub.stream_id.toString()}]; message = { type: "stream", stream_id: general_sub.stream_id, display_recipient: "general", topic: "discussion", }; result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.strictEqual(result, null); // should adjust channel term to match message's display_recipient raw_terms = [{operator: "channel", operand: "999"}]; message = { type: "stream", stream_id: general_sub.stream_id, display_recipient: "general", topic: "discussion", }; let expected = [ {negated: false, operator: "channel", operand: general_sub.stream_id.toString()}, ]; result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.deepStrictEqual(result, expected); // should adjust topic term to match message's topic raw_terms = [{operator: "topic", operand: "random"}]; message = { type: "stream", stream_id: general_sub.stream_id, display_recipient: "general", topic: "discussion", }; expected = [{negated: false, operator: "topic", operand: "discussion"}]; result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.deepStrictEqual(result, expected); // should adjust both channel and topic terms when both are different raw_terms = [ {operator: "channel", operand: "999"}, {operator: "topic", operand: "random"}, ]; message = { type: "stream", stream_id: general_sub.stream_id, display_recipient: "general", topic: "discussion", }; expected = [ {negated: false, operator: "channel", operand: general_sub.stream_id.toString()}, {negated: false, operator: "topic", operand: "discussion"}, ]; result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.deepStrictEqual(result, expected); // should not adjust terms that are not channel or topic raw_terms = [ {operator: "channel", operand: "999"}, {operator: "topic", operand: "random"}, {operator: "sender", operand: alice.user_id}, ]; message = { type: "stream", stream_id: general_sub.stream_id, display_recipient: "general", topic: "discussion", }; expected = [ {negated: false, operator: "channel", operand: general_sub.stream_id.toString()}, {negated: false, operator: "topic", operand: "discussion"}, {negated: false, operator: "sender", operand: alice.user_id}, ]; result = Filter.adjusted_terms_if_moved(raw_terms, message); assert.deepStrictEqual(result, expected); }); run_test("can_newly_match_moved_messages", () => { // Matches channel by ID const stream_id_str = general_sub.stream_id.toString(); let filter = new Filter([{operator: "channel", operand: stream_id_str}]); assert.deepEqual(filter.can_newly_match_moved_messages(stream_id_str, "test"), true); assert.deepEqual(filter.can_newly_match_moved_messages("99999", "test"), false); // Matches topic filter = new Filter([{operator: "topic", operand: "Test topic"}]); assert.deepEqual(filter.can_newly_match_moved_messages("general", "Test topic"), true); assert.deepEqual(filter.can_newly_match_moved_messages("general", "test topic"), true); assert.deepEqual(filter.can_newly_match_moved_messages("general", "random topic"), false); // Matches common narrows filter = new Filter([{operator: "is", operand: "followed"}]); assert.deepEqual(filter.can_newly_match_moved_messages("general", "test"), true); filter = new Filter([{operator: "is", operand: "starred"}]); assert.deepEqual(filter.can_newly_match_moved_messages("general", "test"), false); filter = new Filter([ {negated: true, operator: "channel", operand: general_sub.stream_id.toString()}, ]); assert.deepEqual(filter.can_newly_match_moved_messages("something-else", "test"), true); filter = new Filter([{negated: true, operator: "is", operand: "followed"}]); assert.deepEqual(filter.can_newly_match_moved_messages("general", "test"), true); }); run_test("terms_for_server_query", () => { // Returns the raw terms unchanged (channel operand stays a // string), only dropping the client-side-only `date` operator. const filter = new Filter([ {operator: "channel", operand: "1"}, {operator: "date", operand: "2025-03-01"}, {operator: "topic", operand: "bar"}, ]); assert.deepEqual(filter.terms_for_server_query(), [ {operator: "channel", operand: "1", negated: false}, {operator: "topic", operand: "bar", negated: false}, ]); }); run_test("get_stringified_narrow_for_server_query", () => { const filter = new Filter([ {operator: "channel", operand: "1"}, {operator: "topic", operand: "bar"}, ]); const narrow = filter.get_stringified_narrow_for_server_query(); assert.equal( narrow, '[{"operator":"channel","operand":1,"negated":false},{"operator":"topic","operand":"bar","negated":false}]', ); // Excludes date term if it is present in the filter. const filter2 = new Filter([ {operator: "channel", operand: "1"}, {operator: "date", operand: "2025-03-01"}, {operator: "topic", operand: "bar"}, ]); const narrow2 = filter2.get_stringified_narrow_for_server_query(); assert.equal( narrow2, '[{"operator":"channel","operand":1,"negated":false},{"operator":"topic","operand":"bar","negated":false}]', ); });