paulmataruso/zulip
1
0
Fork 0
mirror of https://github.com/zulip/zulip.git synced 2025-11-04 05:53:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

message_list: Don't always cache "Combined feed" view.

Browse Source 
Important changes in this commit:
* We only cache message list for "Combined feed" if it is the
  default view.

* We modify existing handling of home message list code so that
  it can be used to for any message list that we want to cache
  using a new `preserve_rendered_state` variable.

* narrow_state.filter() returns the filter of combined feed view  list
  instead of `undefined`.

* We start fetching messages from the latest message on app load.

* Messages in all messages data and Recent view are always synced.

* If combined feed view list is not cached, we don't track it's
  last pointer, effectively sending user to the latest unread
  message always .
This commit is contained in:
Aman Agrawal
2024-04-21 03:31:35 +00:00
committed by Tim Abbott
parent 2ccbb9bc00
commit 103c37f23a
31 changed files with 183 additions and 850 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tools/test-js-with-node
View File

@@ -108,6 +108,7 @@ EXEMPT_FILES = make_set(
"web/src/emojisets.ts",
"web/src/favicon.ts",
"web/src/feedback_widget.ts",
"web/src/fetch_status.ts",
"web/src/flatpickr.ts",
"web/src/gear_menu.js",
"web/src/giphy.js",

11
web/e2e-tests/message-basics.test.ts
View File

@@ -11,6 +11,12 @@ async function get_stream_li(page: Page, stream_name: string): Promise<string> {
async function expect_home(page: Page): Promise<void> {
const message_list_id = await common.get_current_msg_list_id(page, true);
await page.waitForSelector(`.message-list[data-message-list-id='${message_list_id}']`, {
visible: true,
});
// Assert that there is only one message list.
assert.equal((await page.$$(".message-list")).length, 1);
assert.strictEqual(await page.title(), "Combined feed - Zulip Dev - Zulip");
await common.check_messages_sent(page, message_list_id, [
["Verona > test", ["verona test a", "verona test b"]],
["Verona > other topic", ["verona other topic c"]],
@@ -107,10 +113,6 @@ async function un_narrow(page: Page): Promise<void> {
await page.keyboard.press("Escape");
}
await page.click("#left-sidebar-navigation-list .top_left_all_messages");
await page.waitForSelector(".message-list .message_row", {visible: true});
// Assert that there is only one message list.
assert.equal((await page.$$(".message-list")).length, 1);
assert.strictEqual(await page.title(), "Combined feed - Zulip Dev - Zulip");
}
async function un_narrow_by_clicking_org_icon(page: Page): Promise<void> {
@@ -322,6 +324,7 @@ async function test_narrow_by_clicking_the_left_sidebar(page: Page): Promise<voi
await expect_all_direct_messages(page);
await un_narrow(page);
await expect_home(page);
}
async function arrow(page: Page, direction: "Up" | "Down"): Promise<void> {

3
web/src/compose_tooltips.ts
View File

@@ -206,7 +206,8 @@ export function initialize(): void {
const narrow_filter = narrow_state.filter();
let display_current_view;
if (narrow_state.is_message_feed_visible()) {
if (narrow_filter === undefined) {
assert(narrow_filter !== undefined);
if (narrow_filter.is_in_home()) {
display_current_view = $t({
defaultMessage: "Currently viewing your combined feed.",
});

2
web/src/hashchange.js
View File

@@ -12,7 +12,6 @@ import * as inbox_ui from "./inbox_ui";
import * as inbox_util from "./inbox_util";
import * as info_overlay from "./info_overlay";
import * as message_fetch from "./message_fetch";
import * as message_lists from "./message_lists";
import * as message_viewport from "./message_viewport";
import * as modals from "./modals";
import * as narrow from "./narrow";
@@ -161,7 +160,6 @@ function do_hashchange_normal(from_reload) {
if (from_reload) {
blueslip.debug("We are narrowing as part of a reload.");
if (message_fetch.initial_narrow_pointer !== undefined) {
message_lists.home.pre_narrow_offset = message_fetch.initial_offset;
narrow_opts.then_select_id = message_fetch.initial_narrow_pointer;
narrow_opts.then_select_offset = message_fetch.initial_narrow_offset;
}

2
web/src/message_edit.js
View File

@@ -1241,7 +1241,7 @@ export function delete_topic(stream_id, topic_name, failures = 0) {
});
}
export function handle_narrow_deactivated() {
export function restore_edit_state_after_message_view_change() {
assert(message_lists.current !== undefined);
for (const [idx, elem] of currently_editing_messages) {
if (message_lists.current.get(idx) !== undefined) {

13
web/src/message_events.js
View File

@@ -166,7 +166,6 @@ export function insert_new_messages(messages, sent_by_this_client) {
message_notifications.received_messages(messages);
stream_list.update_streams_sidebar();
pm_list.update_private_messages();
recent_view_ui.process_messages(messages);
}
export function update_messages(events) {
@@ -532,7 +531,6 @@ export function update_messages(events) {
// propagated edits to be updated (since the topic edits can have
// changed the correct grouping of messages).
if (any_topic_edited || any_stream_changed) {
message_lists.home.update_muting_and_rerender();
// However, we don't need to rerender message_list if
// we just changed the narrow earlier in this function.
//
@@ -542,8 +540,15 @@ export function update_messages(events) {
// edit. Doing so could save significant work, since most
// topic edits will not match the current topic narrow in
// large organizations.
if (!changed_narrow && message_lists.current?.narrowed) {
message_lists.current.update_muting_and_rerender();
for (const list of message_lists.all_rendered_message_lists()) {
if (changed_narrow && list === message_lists.current) {
// Avoid updating current message list if user switched to a different narrow and
// we don't want to preserver the rendered state for the current one.
continue;
}
list.view.rerender_messages(messages_to_rerender, any_message_content_edited);
}
} else {
// If the content of the message was edited, we do a special animation.

217
web/src/message_fetch.js
View File

@@ -3,12 +3,10 @@ import $ from "jquery";
import {all_messages_data} from "./all_messages_data";
import * as blueslip from "./blueslip";
import * as channel from "./channel";
import {Filter} from "./filter";
import * as huddle_data from "./huddle_data";
import * as message_feed_loading from "./message_feed_loading";
import * as message_feed_top_notices from "./message_feed_top_notices";
import * as message_helper from "./message_helper";
import * as message_list_data from "./message_list_data";
import * as message_lists from "./message_lists";
import * as message_util from "./message_util";
import * as narrow_banner from "./narrow_banner";
@@ -19,21 +17,17 @@ import * as stream_data from "./stream_data";
import * as stream_list from "./stream_list";
import * as ui_report from "./ui_report";
export let initial_pointer;
export let initial_offset;
let first_messages_fetch = true;
export let initial_narrow_pointer;
export let initial_narrow_offset;
let is_all_messages_data_loaded = false;
const consts = {
backfill_idle_time: 10 * 1000,
backfill_batch_size: 1000,
narrow_before: 50,
narrow_after: 50,
num_before_home_anchor: 200,
num_after_home_anchor: 200,
recent_view_initial_fetch_size: 400,
initial_backfill_fetch_size: 400,
maximum_initial_backfill_size: 4000,
narrowed_view_backward_batch_size: 100,
narrowed_view_forward_batch_size: 100,
recent_view_fetch_more_batch_size: 1000,
@@ -54,13 +48,6 @@ function process_result(data, opts) {
// messages not tracked in unread.ts during this fetching process.
message_util.do_unread_count_updates(messages, true);
// If we're loading more messages into the home view, save them to
// the all_messages_data as well, as the message_lists.home is
// reconstructed from all_messages_data.
if (opts.msg_list === message_lists.home) {
all_messages_data.add_messages(messages);
}
if (messages.length !== 0) {
if (opts.msg_list) {
// Since this adds messages to the MessageList and renders MessageListView,
@@ -69,21 +56,6 @@ function process_result(data, opts) {
} else {
opts.msg_list_data.add_messages(messages);
}
// To avoid non-contiguous blocks of data in recent view from
// message_lists.home and recent_view_message_list_data, we
// only process data from message_lists.home if we have found
// the newest message in message_lists.home. We check this via
// is_all_messages_data_loaded, to avoid unnecessary
// double-processing of the last batch of messages;
// is_all_messages_data_loaded is set via opts.cont, below.
if (
opts.is_recent_view_data ||
(opts.msg_list === message_lists.home && is_all_messages_data_loaded)
) {
const msg_list_data = opts.msg_list_data ?? opts.msg_list.data;
recent_view_ui.process_messages(messages, msg_list_data);
}
}
huddle_data.process_loaded_messages(messages);
@@ -137,15 +109,6 @@ function get_messages_success(data, opts) {
found_oldest: data.found_oldest,
history_limited: data.history_limited,
});
if (opts.msg_list === message_lists.home) {
// When we update message_lists.home, we need to also update
// the fetch_status data structure for all_messages_data.
all_messages_data.fetch_status.finish_older_batch({
update_loading_indicator: false,
found_oldest: data.found_oldest,
history_limited: data.history_limited,
});
}
message_feed_top_notices.update_top_of_narrow_notices(opts.msg_list);
}
@@ -154,14 +117,6 @@ function get_messages_success(data, opts) {
update_loading_indicator,
found_newest: data.found_newest,
});
if (opts.msg_list === message_lists.home) {
// When we update message_lists.home, we need to also update
// the fetch_status data structure for all_messages_data.
opts.fetch_again = all_messages_data.fetch_status.finish_newer_batch(data.messages, {
update_loading_indicator: false,
found_newest: data.found_newest,
});
}
}
if (opts.msg_list && opts.msg_list.narrowed && opts.msg_list !== message_lists.current) {
@@ -255,16 +210,16 @@ export function load_messages(opts, attempt = 1) {
// data.narrow = opts.msg_list.data.filter.public_terms()
//
// But support for the all_messages_data sharing of data with
// message_lists.home and the (hacky) page_params.narrow feature
// the combined feed view and the (hacky) page_params.narrow feature
// requires a somewhat ugly bundle of conditionals.
if (msg_list_data.filter.is_in_home()) {
if (page_params.narrow_stream !== undefined) {
data.narrow = JSON.stringify(page_params.narrow);
}
// Otherwise, we don't pass narrow for message_lists.home; this is
// required because it shares its data with all_msg_list, and
// so we need the server to send us message history from muted
// streams and topics even though message_lists.home's in:home
// Otherwise, we don't pass narrow for the combined feed view; this is
// required to display messages if their muted status changes without a new
// network request, and so we need the server to send us message history from muted
// streams and topics even though the combined feed view's in:home
// operators will filter those.
} else {
let terms = msg_list_data.filter.public_terms();
@@ -280,11 +235,6 @@ export function load_messages(opts, attempt = 1) {
msg_list_data.fetch_status.start_older_batch({
update_loading_indicator,
});
if (opts.msg_list === message_lists.home) {
all_messages_data.fetch_status.start_older_batch({
update_loading_indicator,
});
}
}
if (opts.num_after > 0) {
@@ -293,11 +243,6 @@ export function load_messages(opts, attempt = 1) {
msg_list_data.fetch_status.start_newer_batch({
update_loading_indicator,
});
if (opts.msg_list === message_lists.home) {
all_messages_data.fetch_status.start_newer_batch({
update_loading_indicator,
});
}
}
data.client_gravatar = true;
@@ -416,12 +361,8 @@ export function load_messages_for_narrow(opts) {
});
}
export function get_backfill_anchor(msg_list) {
const oldest_msg =
msg_list === message_lists.home
? all_messages_data.first_including_muted()
: msg_list.data.first_including_muted();
export function get_backfill_anchor(msg_list_data) {
const oldest_msg = msg_list_data.first_including_muted();
if (oldest_msg) {
return oldest_msg.id;
}
@@ -430,10 +371,7 @@ export function get_backfill_anchor(msg_list) {
}
export function get_frontfill_anchor(msg_list) {
const last_msg =
msg_list === message_lists.home
? all_messages_data.last_including_muted()
: msg_list.data.last_including_muted();
const last_msg = msg_list.data.last_including_muted();
if (last_msg) {
return last_msg.id;
@@ -469,15 +407,15 @@ export function maybe_load_older_messages(opts) {
// This function gets called when you scroll to the top
// of your window, and you want to get messages older
// than what the browsers originally fetched.
const msg_list = opts.msg_list;
if (!msg_list.data.fetch_status.can_load_older_messages()) {
const msg_list_data = opts.msg_list_data ?? opts.msg_list.data;
if (!msg_list_data.fetch_status.can_load_older_messages()) {
// We may already be loading old messages or already
// got the oldest one.
return;
}
do_backfill({
msg_list,
...opts,
num_before: opts.recent_view
? consts.recent_view_fetch_more_batch_size
: consts.narrowed_view_backward_batch_size,
@@ -485,14 +423,18 @@ export function maybe_load_older_messages(opts) {
}
export function do_backfill(opts) {
const msg_list = opts.msg_list;
const anchor = get_backfill_anchor(msg_list);
const msg_list_data = opts.msg_list_data ?? opts.msg_list.data;
const anchor = get_backfill_anchor(msg_list_data);
// `load_messages` behaves differently for `msg_list` and `msg_list_data` as
// parameters as which one is passed affects the behavior of the function.
// So, we need to need them as they were provided to us.
load_messages({
anchor,
num_before: opts.num_before,
num_after: 0,
msg_list,
msg_list: opts.msg_list,
msg_list_data: opts.msg_list_data,
cont() {
if (opts.cont) {
opts.cont();
@@ -541,15 +483,13 @@ export function start_backfilling_messages() {
onIdle() {
do_backfill({
num_before: consts.backfill_batch_size,
msg_list: message_lists.home,
msg_list_data: all_messages_data,
});
},
});
}
export function set_initial_pointer_and_offset({pointer, offset, narrow_pointer, narrow_offset}) {
initial_pointer = pointer;
initial_offset = offset;
export function set_initial_pointer_and_offset({narrow_pointer, narrow_offset}) {
initial_narrow_pointer = narrow_pointer;
initial_narrow_offset = narrow_offset;
}
@@ -557,36 +497,19 @@ export function set_initial_pointer_and_offset({pointer, offset, narrow_pointer,
export function initialize(finished_initial_fetch) {
// get the initial message list
function load_more(data) {
// If we haven't selected a message in the home view yet, and
// the home view isn't empty, we select the anchor message here.
if (message_lists.home.selected_id() === -1 && !message_lists.home.visibly_empty()) {
// We fall back to the closest selected id, as the user
// may have removed a stream from the home view while we
// were loading data.
message_lists.home.select_id(data.anchor, {
then_scroll: true,
use_closest: true,
target_scroll_offset: initial_offset,
});
if (first_messages_fetch) {
// See server_events.js for this callback.
// Start processing server events.
finished_initial_fetch();
recent_view_ui.hide_loading_indicator();
first_messages_fetch = false;
}
if (data.found_newest) {
// Mark that we've finishing loading all the way to the
// present in the all_messages_data data set. At this
// time, it's safe to call recent_view_ui.process_messages
// with all the messages in our cache.
is_all_messages_data_loaded = true;
recent_view_ui.process_messages(all_messages_data.all_messages(), all_messages_data);
if (page_params.is_spectator) {
// Since for spectators, this is the main fetch, we
// hide the Recent Conversations loading indicator here.
recent_view_ui.hide_loading_indicator();
}
// See server_events.js for this callback.
finished_initial_fetch();
if (data.found_oldest) {
return;
}
if (all_messages_data.num_items() >= consts.maximum_initial_backfill_size) {
start_backfilling_messages();
return;
}
@@ -596,72 +519,25 @@ export function initialize(finished_initial_fetch) {
//
// But we do it with a bit of delay, to reduce risk that we
// hit rate limits with these backfills.
const latest_id = data.messages.at(-1).id;
const oldest_id = data.messages.at(0).id;
setTimeout(() => {
load_messages({
anchor: latest_id,
num_before: 0,
num_after: consts.catch_up_batch_size,
msg_list: message_lists.home,
anchor: oldest_id,
num_before: consts.catch_up_batch_size,
num_after: 0,
msg_list_data: all_messages_data,
cont: load_more,
});
}, consts.catch_up_backfill_delay);
}
let anchor;
if (initial_pointer !== undefined) {
// If we're doing a server-initiated reload, similar to a
// near: narrow query, we want to select a specific message.
anchor = initial_pointer;
} else {
// Otherwise, we should just use the first unread message in
// the user's unmuted history as our anchor.
anchor = "first_unread";
}
load_messages({
anchor,
num_before: consts.num_before_home_anchor,
num_after: consts.num_after_home_anchor,
msg_list: message_lists.home,
cont: load_more,
// Since `all_messages_data` contains continuous message history
// which always contains the latest message, it makes sense for
// Recent view to display the same data and be in sync.
all_messages_data.set_add_messages_callback((messages) => {
recent_view_ui.process_messages(messages, all_messages_data);
});
if (page_params.is_spectator) {
// Since spectators never have old unreads, we can skip the
// hacky fetch below for them (which would just waste resources).
// This optimization requires a bit of duplicated loading
// indicator code, here and hiding logic in hide_more.
recent_view_ui.show_loading_indicator();
return;
}
// In addition to the algorithm above, which is designed to ensure
// that we fetch all message history eventually starting with the
// first unread message, we also need to ensure that the Recent
// Topics page contains the very most recent threads on page load.
//
// Long term, we'll want to replace this with something that's
// more performant (i.e. avoids this unnecessary extra fetch the
// results of which are basically discarded) and better represents
// more than a few hundred messages' history, but this strategy
// allows "Recent Conversations" to always show current data (with gaps)
// on page load; the data will be complete once the algorithm
// above catches up to present.
//
// (Users will see a weird artifact where Recent Conversations has a gap
// between E.g. 6 days ago and 37 days ago while the catchup
// process runs, so this strategy still results in problematic
// visual artifacts shortly after page load; just more forgivable
// ones).
//
// We only initialize MessageListData here, since we don't
// want update the UI and confuse the functions in MessageList.
// Recent view can handle the UI updates itself.
const recent_view_message_list_data = new message_list_data.MessageListData({
filter: new Filter([{operator: "in", operand: "home"}]),
excludes_muted_topics: true,
});
// TODO: Ideally we'd have loading indicators for Recent Conversations
// at both top and bottom be managed by load_messages, but that
// likely depends on other reorganizations of the early loading
@@ -669,10 +545,9 @@ export function initialize(finished_initial_fetch) {
recent_view_ui.show_loading_indicator();
load_messages({
anchor: "newest",
num_before: consts.recent_view_initial_fetch_size,
num_before: consts.initial_backfill_fetch_size,
num_after: 0,
msg_list_data: recent_view_message_list_data,
is_recent_view_data: true,
cont: recent_view_ui.hide_loading_indicator,
msg_list_data: all_messages_data,
cont: load_more,
});
}

43
web/src/message_list.js
View File

@@ -2,13 +2,10 @@ import autosize from "autosize";
import $ from "jquery";
import assert from "minimalistic-assert";
import {all_messages_data} from "./all_messages_data";
import * as blueslip from "./blueslip";
import {Filter} from "./filter";
import {MessageListData} from "./message_list_data";
import * as message_list_tooltips from "./message_list_tooltips";
import {MessageListView} from "./message_list_view";
import * as message_lists from "./message_lists";
import * as narrow_banner from "./narrow_banner";
import * as narrow_state from "./narrow_state";
import {page_params} from "./page_params";
@@ -59,8 +56,7 @@ export class MessageList {
// DOM.
this.view = new MessageListView(this, collapse_messages, opts.is_node_test);
// Whether this is a narrowed message list. The only message
// list that is not is the home_msg_list global.
// If this message list is not for the global feed.
this.narrowed = !this.data.filter.is_in_home();
// Keeps track of whether the user has done a UI interaction,
@@ -72,6 +68,17 @@ export class MessageList {
// the user. Possibly this can be unified in some nice way.
this.reading_prevented = false;
// Whether this message list's is preserved in the DOM even
// when viewing other views -- a valuable optimization for
// fast toggling between the combined feed and other views,
// which we enable only when that is the user's home view.
//
// This is intentionally not live-updated when web_home_view
// changes, since it's easier to reason about if this
// optimization is active or not for an entire session.
this.preserve_rendered_state =
user_settings.web_home_view === "all_messages" && !this.narrowed;
return this;
}
@@ -110,14 +117,14 @@ export class MessageList {
render_info = this.append_to_view(bottom_messages, opts);
}
if (this.narrowed && !this.visibly_empty()) {
if (!this.visibly_empty()) {
// If adding some new messages to the message tables caused
// our current narrow to no longer be empty, hide the empty
// feed placeholder text.
narrow_banner.hide_empty_narrow_message();
}
if (this.narrowed && !this.visibly_empty() && this.selected_id() === -1) {
if (!this.visibly_empty() && this.selected_id() === -1) {
// The message list was previously empty, but now isn't
// due to adding these messages, and we need to select a
// message. Regardless of whether the messages are new or
@@ -468,19 +475,6 @@ export class MessageList {
}
update_muting_and_rerender() {
// For the home message list, we need to re-initialize
// _all_items for stream muting/topic unmuting from
// all_messages_data, since otherwise unmuting a previously
// muted stream won't work.
//
// "in-home" filter doesn't included muted stream messages, so we
// need to repopulate the message list with all messages to include
// the previous messages in muted streams so that update_items_for_muting works.
if (this.data.filter.is_in_home()) {
this.data.clear();
this.data.add_messages(all_messages_data.all_messages());
}
this.data.update_items_for_muting();
// We need to rerender whether or not the narrow hides muted
// topics, because we need to update recipient bars for topics
@@ -529,12 +523,3 @@ export class MessageList {
return this.data.get_last_message_sent_by_me();
}
}
export function initialize() {
/* Create home_msg_list and register it. */
const home_msg_list = new MessageList({
filter: new Filter([{operator: "in", operand: "home"}]),
excludes_muted_topics: true,
});
message_lists.set_home(home_msg_list);
}

10
web/src/message_list_data.ts
View File

@@ -41,6 +41,8 @@ export class MessageListData {
// there are no messages matching the current filter.
_selected_id: number;
predicate?: (message: Message) => boolean;
// This is a callback that is called when messages are added to the message list.
add_messages_callback?: (messages: Message[]) => void;
// MessageListData is a core data structure for keeping track of a
// contiguous block of messages matching a given narrow that can
@@ -60,6 +62,10 @@ export class MessageListData {
this._selected_id = -1;
}
set_add_messages_callback(callback: () => void): void {
this.add_messages_callback = callback;
}
all_messages(): Message[] {
return this._items;
}
@@ -333,6 +339,10 @@ export class MessageListData {
bottom_messages = this.append(bottom_messages);
}
if (this.add_messages_callback) {
this.add_messages_callback(messages);
}
const info = {
top_messages,
bottom_messages,

46
web/src/message_lists.ts
View File

@@ -1,5 +1,4 @@
import $ from "jquery";
import assert from "minimalistic-assert";
import * as blueslip from "./blueslip";
import * as inbox_util from "./inbox_util";
@@ -33,6 +32,7 @@ export type SelectIdOpts = {
export type MessageList = {
id: number;
preserve_rendered_state: boolean;
view: MessageListView;
selected_id: () => number;
selected_row: () => JQuery;
@@ -52,39 +52,37 @@ export type MessageList = {
) => RenderInfo | undefined;
};
export let home: MessageList | undefined;
export let current: MessageList | undefined;
export const rendered_message_lists = new Map<number, MessageList>();
export function set_current(msg_list: MessageList | undefined): void {
// NOTE: Use update_current_message_list instead of this function.
// NOTE: Strictly used for mocking in node tests.
// Use `update_current_message_list` instead in production.
current = msg_list;
}
export function update_current_message_list(msg_list: MessageList | undefined): void {
if (msg_list !== home) {
home?.view.$list.removeClass("focused-message-list");
if (current && !current.preserve_rendered_state) {
// Remove the current message list from the DOM.
current.view.$list.remove();
rendered_message_lists.delete(current.id);
} else {
current?.view.$list.removeClass("focused-message-list");
}
if (current !== home) {
// Remove old msg list from DOM.
current?.view.$list.remove();
current = msg_list;
if (current !== undefined) {
rendered_message_lists.set(current.id, current);
current.view.$list.addClass("focused-message-list");
}
set_current(msg_list);
current?.view.$list.addClass("focused-message-list");
}
export function set_home(msg_list: MessageList): void {
home = msg_list;
}
export function all_rendered_message_lists(): MessageList[] {
assert(home !== undefined);
const rendered_message_lists = [home];
if (current !== undefined && current !== home) {
rendered_message_lists.push(current);
}
return rendered_message_lists;
return [...rendered_message_lists.values()];
}
export function add_rendered_message_list(msg_list: MessageList): void {
rendered_message_lists.set(msg_list.id, msg_list);
}
export function all_rendered_row_for_message_id(message_id: number): JQuery {
@@ -112,7 +110,11 @@ export function update_recipient_bar_background_color(): void {
}
export function save_pre_narrow_offset_for_reload(): void {
if (current === undefined) {
// Only save the pre_narrow_offset if the message list will be cached if user
// switches to a different narrow, otherwise the pre_narrow_offset would just be lost when
// user switches to a different narrow. In case of a reload, offset for the current
// message is captured and restored by `reload` library.
if (!current?.preserve_rendered_state) {
return;
}

39
web/src/narrow.js
View File

@@ -59,7 +59,6 @@ import * as util from "./util";
import * as widgetize from "./widgetize";
const LARGER_THAN_MAX_MESSAGE_ID = 10000000000000000;
export let has_visited_all_messages = false;
export function reset_ui_state() {
// Resets the state of various visual UI elements that are
@@ -98,7 +97,7 @@ export function activate(raw_terms, opts) {
raw_terms: Narrowing/search terms; used to construct
a Filter object that decides which messages belong in the
view. Required (See the above note on how `message_lists.home` works)
view.
All other options are encoded via the `opts` dictionary:
@@ -128,14 +127,14 @@ export function activate(raw_terms, opts) {
raw_terms = [{operator: "is", operand: "home"}];
}
const filter = new Filter(raw_terms);
const is_narrowed_to_all_messages_view = narrow_state.filter()?.is_in_home();
if (has_visited_all_messages && is_narrowed_to_all_messages_view && filter.is_in_home()) {
const is_combined_feed_global_view = filter.is_in_home();
const is_narrowed_to_combined_feed_view = narrow_state.filter()?.is_in_home();
if (is_narrowed_to_combined_feed_view && is_combined_feed_global_view) {
// If we're already looking at the combined feed, exit without doing any work.
return;
}
if (filter.is_in_home() && message_scroll_state.actively_scrolling) {
if (is_combined_feed_global_view && message_scroll_state.actively_scrolling) {
// TODO: Figure out why puppeteer test for this fails when run for narrows
// other than `Combined feed`.
@@ -149,8 +148,7 @@ export function activate(raw_terms, opts) {
}
// Use to determine if user read any unread messages outside the combined feed.
// BUG: This doesn't check for the combined feed?
const was_narrowed_already = narrow_state.filter() !== undefined;
const was_narrowed_already = message_lists.current?.narrowed;
// Since narrow.activate is called directly from various
// places in our code without passing through hashchange,
@@ -161,7 +159,7 @@ export function activate(raw_terms, opts) {
// TODO: is:home is currently not permitted for spectators
// because they can't mute things; maybe that's the wrong
// policy?
!filter.is_in_home() &&
!is_combined_feed_global_view &&
raw_terms.some(
(raw_term) => !hash_parser.allowed_web_public_narrows.includes(raw_term.operator),
)
@@ -424,11 +422,21 @@ export function activate(raw_terms, opts) {
const excludes_muted_topics = filter.excludes_muted_topics();
// Check if we already have a rendered message list for the `filter`.
// TODO: If we add a message list other than `is_in_home` to be save as rendered,
// we need to add a `is_equal` function to `Filter` to compare the filters.
let msg_list;
if (filter.is_in_home()) {
has_visited_all_messages = true;
msg_list = message_lists.home;
} else {
let restore_rendered_list = false;
for (const list of message_lists.all_rendered_message_lists()) {
if (is_combined_feed_global_view && list.preserve_rendered_state) {
assert(list.data.filter.is_in_home());
msg_list = list;
restore_rendered_list = true;
break;
}
}
if (!restore_rendered_list) {
let msg_data = new MessageListData({
filter,
excludes_muted_topics,
@@ -461,7 +469,6 @@ export function activate(raw_terms, opts) {
}
assert(msg_list !== undefined);
narrow_state.set_has_shown_message_list_view();
// Show the new set of messages. It is important to set message_lists.current to
// the view right as it's being shown, because we rely on message_lists.current
// being shown for deciding when to condense messages.
@@ -473,7 +480,7 @@ export function activate(raw_terms, opts) {
let select_immediately;
let select_opts;
let then_select_offset;
if (filter.is_in_home()) {
if (restore_rendered_list) {
select_immediately = true;
select_opts = {
empty_ok: true,
@@ -502,7 +509,7 @@ export function activate(raw_terms, opts) {
message_lists.current.resume_reading();
// Reset the collapsed status of messages rows.
condense.condense_and_collapse(message_lists.current.view.$list.find(".message_row"));
message_edit.handle_narrow_deactivated();
message_edit.restore_edit_state_after_message_view_change();
widgetize.set_widgets_for_list();
message_feed_top_notices.update_top_of_narrow_notices(msg_list);

2
web/src/narrow_banner.ts
View File

@@ -92,7 +92,7 @@ function pick_empty_narrow_banner(): NarrowBannerData {
const current_filter = narrow_state.filter();
if (current_filter === undefined) {
if (current_filter === undefined || current_filter.is_in_home()) {
return default_banner;
}

14
web/src/narrow_state.ts
View File

@@ -8,15 +8,9 @@ import * as stream_data from "./stream_data";
import type {StreamSubscription} from "./sub_store";
import * as unread from "./unread";
export let has_shown_message_list_view = false;
export function filter(): Filter | undefined {
// `Combined feed`, `Recent Conversations` and `Inbox` return undefined;
if (message_lists.current === undefined || message_lists.current.data.filter.is_in_home()) {
return undefined;
}
return message_lists.current.data.filter;
// `Recent Conversations` and `Inbox` return undefined;
return message_lists.current?.data.filter;
}
export function search_terms(current_filter: Filter | undefined = filter()): NarrowTerm[] {
@@ -381,7 +375,3 @@ export function is_for_stream_id(stream_id: number, filter?: Filter): boolean {
return stream_id === narrow_sub.stream_id;
}
export function set_has_shown_message_list_view(): void {
has_shown_message_list_view = true;
}

9
web/src/recent_view_ui.js
View File

@@ -403,14 +403,7 @@ export function hide_loading_indicator() {
}
export function process_messages(messages, msg_list_data) {
// This code path processes messages from 3 sources:
// 1. Newly sent messages from the server_events system. This is safe to
// process because we always will have the latest previously sent messages.
// 2. Messages in all_messages_data, the main cache of contiguous
// message history that the client maintains.
// 3. Latest messages fetched specifically for Recent view when
// the browser first loads. We will be able to remove this once
// all_messages_data is fetched in a better order.
// Always synced with messages in all_messages_data.
let conversation_data_updated = false;
if (messages.length > 0) {

32
web/src/reload.js
View File

@@ -26,7 +26,7 @@ function call_reload_hooks() {
}
}
function preserve_state(send_after_reload, save_pointer, save_compose) {
function preserve_state(send_after_reload, save_compose) {
if (!localstorage.supported()) {
// If local storage is not supported by the browser, we can't
// save the browser's position across reloads (since there's
@@ -68,23 +68,7 @@ function preserve_state(send_after_reload, save_pointer, save_compose) {
}
}
if (save_pointer) {
const pointer = message_lists.home.selected_id();
if (pointer !== -1) {
url += "+pointer=" + pointer;
}
}
if (message_lists.current === message_lists.home) {
const $row = message_lists.home.selected_row();
if ($row.length > 0) {
url += "+offset=" + $row.get_offset_to_window().top;
}
} else if (message_lists.current !== undefined) {
url += "+offset=" + message_lists.home.pre_narrow_offset;
// narrow_state.filter() is not undefined, so this is the current
// narrowed message list.
if (message_lists.current !== undefined) {
const narrow_pointer = message_lists.current.selected_id();
if (narrow_pointer !== -1) {
url += "+narrow_pointer=" + narrow_pointer;
@@ -93,8 +77,6 @@ function preserve_state(send_after_reload, save_pointer, save_compose) {
if ($narrow_row.length > 0) {
url += "+narrow_offset=" + $narrow_row.get_offset_to_window().top;
}
} else {
url += "+offset=" + message_lists.home.pre_narrow_offset;
}
url += hash_util.build_reload_url();
@@ -146,7 +128,7 @@ function delete_stale_tokens(ls) {
);
}
function do_reload_app(send_after_reload, save_pointer, save_compose, message_html) {
function do_reload_app(send_after_reload, save_compose, message_html) {
if (reload_state.is_in_progress()) {
blueslip.log("do_reload_app: Doing nothing since reload_in_progress");
return;
@@ -154,7 +136,7 @@ function do_reload_app(send_after_reload, save_pointer, save_compose, message_ht
// TODO: we should completely disable the UI here
try {
preserve_state(send_after_reload, save_pointer, save_compose);
preserve_state(send_after_reload, save_compose);
} catch (error) {
blueslip.error("Failed to preserve state", undefined, error);
}
@@ -199,13 +181,12 @@ function do_reload_app(send_after_reload, save_pointer, save_compose, message_ht
export function initiate({
immediate = false,
save_pointer = true,
save_compose = true,
send_after_reload = false,
message_html = "Reloading ...",
}) {
if (immediate) {
do_reload_app(send_after_reload, save_pointer, save_compose, message_html);
do_reload_app(send_after_reload, save_compose, message_html);
}
if (reload_state.is_pending() || reload_state.is_in_progress()) {
@@ -242,7 +223,7 @@ export function initiate({
let compose_started_handler;
function reload_from_idle() {
do_reload_app(false, save_pointer, save_compose, message_html);
do_reload_app(false, save_compose, message_html);
}
// Make sure we always do a reload eventually after
@@ -296,7 +277,6 @@ reload_state.set_csrf_failed_handler(() => {
initiate({
immediate: true,
save_pointer: true,
save_compose: true,
});
});

10
web/src/reload_setup.js
View File

@@ -68,13 +68,15 @@ export function initialize() {
}
}
const pointer = Number.parseInt(vars.pointer, 10);
const offset = Number.parseInt(vars.offset, 10);
// We only restore pointer and offset for the current narrow, even if there are narrows that
// were cached before the reload, they are no longer cached after the reload. We could possibly
// store the pointer and offset for these narrows but it might lead to a confusing experience if
// user gets back to these narrow much later (maybe days) and finds them at a random position in
// narrow which they didn't navigate to while they were trying to just get to the latest unread
// message in that narrow which will now take more effort to find.
const narrow_pointer = Number.parseInt(vars.narrow_pointer, 10);
const narrow_offset = Number.parseInt(vars.narrow_offset, 10);
message_fetch.set_initial_pointer_and_offset({
pointer: Number.isNaN(pointer) ? undefined : pointer,
offset: Number.isNaN(offset) ? undefined : offset,
narrow_pointer: Number.isNaN(narrow_pointer) ? undefined : narrow_pointer,
narrow_offset: Number.isNaN(narrow_offset) ? undefined : narrow_offset,
});

6
web/src/server_events.js
View File

@@ -5,7 +5,6 @@ import * as blueslip from "./blueslip";
import * as channel from "./channel";
import * as echo from "./echo";
import * as message_events from "./message_events";
import * as message_lists from "./message_lists";
import {page_params} from "./page_params";
import * as reload from "./reload";
import * as reload_state from "./reload_state";
@@ -128,10 +127,6 @@ function get_events_success(events) {
}
}
if (message_lists.home.selected_id() === -1 && !message_lists.home.visibly_empty()) {
message_lists.home.select_id(message_lists.home.first().id, {then_scroll: false});
}
if (update_message_events.length !== 0) {
try {
message_events.update_messages(update_message_events);
@@ -221,7 +216,6 @@ function get_events({dont_block = false} = {}) {
event_queue_expired = true;
reload.initiate({
immediate: true,
save_pointer: false,
save_compose: true,
});
return;

1
web/src/server_events_dispatch.js
View File

@@ -175,7 +175,6 @@ export function dispatch_normal_event(event) {
case "web_reload_client": {
const reload_options = {
save_pointer: true,
save_compose: true,
message_html: "The application has been updated; reloading!",
};

1
web/src/transmit.js
View File

@@ -62,7 +62,6 @@ export function send_message(request, on_success, error) {
// The error might be due to the server changing
reload.initiate({
immediate: true,
save_pointer: true,
save_compose: true,
send_after_reload: true,
});

5
web/src/ui_init.js
View File

@@ -14,6 +14,7 @@ import * as activity from "./activity";
import * as activity_ui from "./activity_ui";
import * as add_stream_options_popover from "./add_stream_options_popover";
import * as alert_words from "./alert_words";
import {all_messages_data} from "./all_messages_data";
import * as audible_notifications from "./audible_notifications";
import * as blueslip from "./blueslip";
import * as bot_data from "./bot_data";
@@ -63,7 +64,6 @@ import * as markdown_config from "./markdown_config";
import * as message_actions_popover from "./message_actions_popover";
import * as message_edit_history from "./message_edit_history";
import * as message_fetch from "./message_fetch";
import * as message_list from "./message_list";
import * as message_list_hover from "./message_list_hover";
import * as message_list_tooltips from "./message_list_tooltips";
import * as message_lists from "./message_lists";
@@ -726,7 +726,6 @@ export function initialize_everything(state_data) {
realm_logo.initialize();
message_lists.initialize();
message_list.initialize();
recent_view_ui.initialize({
on_click_participant(avatar_element, participant_user_id) {
const user = people.get_by_user_id(participant_user_id);
@@ -736,7 +735,7 @@ export function initialize_everything(state_data) {
on_mark_topic_as_read: unread_ops.mark_topic_as_read,
maybe_load_older_messages() {
message_fetch.maybe_load_older_messages({
msg_list: message_lists.home,
msg_list_data: all_messages_data,
recent_view: true,
});
},

9
web/src/user_topics_ui.js
View File

@@ -47,10 +47,11 @@ export function handle_topic_updates(user_topic_event) {
}
setTimeout(0, () => {
/* Rerender the combined feed view if necessary, but defer until after
* the browser has rendered the DOM updates scheduled above. */
if (message_lists.current !== message_lists.home) {
message_lists.home.update_muting_and_rerender();
// Defer updates for any background-rendered messages lists until the visible one has been updated.
for (const list of message_lists.all_rendered_message_lists()) {
if (list.preserve_rendered_state && message_lists.current !== list) {
list.update_muting_and_rerender();
}
}
});
}

4
web/src/views_util.ts
View File

@@ -72,9 +72,7 @@ export function show(opts: {
complete_rerender: () => void;
is_recent_view?: boolean;
}): void {
if (narrow_state.has_shown_message_list_view) {
message_lists.save_pre_narrow_offset_for_reload();
}
message_lists.save_pre_narrow_offset_for_reload();
if (opts.is_visible()) {
// If we're already visible, E.g. because the user hit Esc

17
web/tests/dispatch.test.js
View File

@@ -92,6 +92,7 @@ const user_groups = mock_esm("../src/user_groups");
const user_group_edit = mock_esm("../src/user_group_edit");
const overlays = mock_esm("../src/overlays");
mock_esm("../src/giphy");
const {Filter} = zrequire("filter");
const electron_bridge = set_global("electron_bridge", {});
@@ -101,19 +102,17 @@ message_lists.current = {
rerender_view: noop,
data: {
get_messages_sent_by_user: () => [],
filter: {
is_in_home: () => true,
},
filter: new Filter([]),
},
};
message_lists.home = {
const cached_message_list = {
get_row: noop,
rerender_view: noop,
data: {
get_messages_sent_by_user: () => [],
},
};
message_lists.all_rendered_message_lists = () => [message_lists.home, message_lists.current];
message_lists.all_rendered_message_lists = () => [cached_message_list, message_lists.current];
// page_params is highly coupled to dispatching now
page_params.test_suite = false;
@@ -783,7 +782,6 @@ run_test("web_reload_client", ({override}) => {
dispatch(event);
assert.equal(stub.num_calls, 1);
const args = stub.get_args("options");
assert.equal(args.options.save_pointer, true);
assert.equal(args.options.immediate, true);
});
@@ -890,13 +888,16 @@ run_test("user_settings", ({override}) => {
message_lists.current.rerender = () => {
called = true;
};
override(message_lists.home, "rerender", noop);
let called_for_cached_msg_list = false;
cached_message_list.rerender = () => {
called_for_cached_msg_list = true;
};
event = event_fixtures.user_settings__twenty_four_hour_time;
user_settings.twenty_four_hour_time = false;
dispatch(event);
assert_same(user_settings.twenty_four_hour_time, true);
assert_same(called, true);
assert_same(called_for_cached_msg_list, true);
event = event_fixtures.user_settings__translate_emoticons;
user_settings.translate_emoticons = false;

13
web/tests/echo.test.js
View File

@@ -41,14 +41,15 @@ message_lists.current = {
},
change_message_id: noop,
};
message_lists.home = {
const home_msg_list = {
view: {
rerender_messages: noop,
change_message_id: noop,
},
preserver_rendered_state: true,
change_message_id: noop,
};
message_lists.all_rendered_message_lists = () => [message_lists.home, message_lists.current];
message_lists.all_rendered_message_lists = () => [home_msg_list, message_lists.current];
const echo = zrequire("echo");
const people = zrequire("people");
@@ -76,7 +77,7 @@ run_test("process_from_server for un-echoed messages", () => {
run_test("process_from_server for differently rendered messages", ({override}) => {
let messages_to_rerender = [];
override(message_lists.home.view, "rerender_messages", (msgs) => {
override(home_msg_list.view, "rerender_messages", (msgs) => {
messages_to_rerender = msgs;
});
@@ -193,13 +194,13 @@ run_test("build_display_recipient", () => {
});
run_test("update_message_lists", () => {
message_lists.home.view = {};
home_msg_list.view = {};
const stub = make_stub();
const view_stub = make_stub();
message_lists.home.change_message_id = stub.f;
message_lists.home.view.change_message_id = view_stub.f;
home_msg_list.change_message_id = stub.f;
home_msg_list.view.change_message_id = view_stub.f;
echo.update_message_lists({old_id: 401, new_id: 402});

7
web/tests/example5.test.js
View File

@@ -25,7 +25,6 @@ const message_lists = mock_esm("../src/message_lists");
const message_notifications = mock_esm("../src/message_notifications");
const message_util = mock_esm("../src/message_util");
const pm_list = mock_esm("../src/pm_list");
const recent_view_data = mock_esm("../src/recent_view_data");
const stream_list = mock_esm("../src/stream_list");
const unread_ops = mock_esm("../src/unread_ops");
const unread_ui = mock_esm("../src/unread_ui");
@@ -39,8 +38,7 @@ message_lists.current = {
},
},
};
message_lists.home = message_lists.current;
message_lists.all_rendered_message_lists = () => [message_lists.home, message_lists.current];
message_lists.all_rendered_message_lists = () => [message_lists.current];
// And we will also test some real code, of course.
const message_events = zrequire("message_events");
@@ -101,7 +99,6 @@ run_test("insert_message", ({override}) => {
helper.redirect(message_notifications, "received_messages");
helper.redirect(message_util, "add_new_messages_data");
helper.redirect(message_util, "add_new_messages");
helper.redirect(recent_view_data, "process_message");
helper.redirect(stream_list, "update_streams_sidebar");
helper.redirect(unread_ops, "process_visible");
helper.redirect(unread_ui, "update_unread_counts");
@@ -116,12 +113,10 @@ run_test("insert_message", ({override}) => {
[huddle_data, "process_loaded_messages"],
[message_util, "add_new_messages_data"],
[message_util, "add_new_messages"],
[message_util, "add_new_messages"],
[unread_ui, "update_unread_counts"],
[unread_ops, "process_visible"],
[message_notifications, "received_messages"],
[stream_list, "update_streams_sidebar"],
[recent_view_data, "process_message"],
]);
// Despite all of our stubbing/mocking, the call to

4
web/tests/example7.test.js
View File

@@ -59,8 +59,7 @@ const message_viewport = mock_esm("../src/message_viewport");
const unread_ui = mock_esm("../src/unread_ui");
message_lists.current = {view: {}};
message_lists.home = {view: {}};
message_lists.all_rendered_message_lists = () => [message_lists.home, message_lists.current];
message_lists.all_rendered_message_lists = () => [message_lists.current];
const message_store = zrequire("message_store");
const stream_data = zrequire("stream_data");
@@ -107,7 +106,6 @@ run_test("unread_ops", ({override}) => {
// Ignore these interactions for now:
override(message_lists.current.view, "show_message_as_read", noop);
override(message_lists.home.view, "show_message_as_read", noop);
override(desktop_notifications, "close_notification", noop);
override(unread_ui, "update_unread_counts", noop);
override(unread_ui, "notify_messages_remain_unread", noop);

3
web/tests/message_events.test.js
View File

@@ -14,7 +14,7 @@ const pm_list = mock_esm("../src/pm_list");
const stream_list = mock_esm("../src/stream_list");
const unread_ui = mock_esm("../src/unread_ui");
message_lists.current = {};
message_lists.all_rendered_message_lists = () => [message_lists.home, message_lists.current];
message_lists.all_rendered_message_lists = () => [message_lists.current];
const people = zrequire("people");
const message_events = zrequire("message_events");
@@ -95,7 +95,6 @@ run_test("update_messages", () => {
rendered_mgs = msgs_to_rerender;
assert.equal(message_content_edited, true);
};
message_lists.home = message_lists.current;
const side_effects = [
[message_edit, "end_message_edit"],

490
web/tests/message_fetch.test.js
View File

@@ -1,490 +0,0 @@
"use strict";
const {strict: assert} = require("assert");
const _ = require("lodash");
const {mock_esm, set_global, zrequire} = require("./lib/namespace");
const {run_test, noop} = require("./lib/test");
const $ = require("./lib/zjquery");
const {page_params} = require("./lib/zpage_params");
set_global("document", "document-stub");
function MessageListView() {
return {
maybe_rerender: noop,
append: noop,
prepend: noop,
};
}
mock_esm("../src/message_list_view", {
MessageListView,
});
mock_esm("../src/recent_view_ui", {
process_messages: noop,
show_loading_indicator: noop,
hide_loading_indicator: noop,
set_oldest_message_date: noop,
});
mock_esm("../src/ui_report", {
hide_error: noop,
});
const channel = mock_esm("../src/channel");
const message_helper = mock_esm("../src/message_helper");
const message_lists = mock_esm("../src/message_lists");
const message_util = mock_esm("../src/message_util");
const stream_list = mock_esm("../src/stream_list", {
maybe_scroll_narrow_into_view() {},
});
mock_esm("../src/message_feed_top_notices", {
update_top_of_narrow_notices() {},
});
mock_esm("../src/message_feed_loading", {
show_loading_older: noop,
hide_loading_older: noop,
show_loading_newer: noop,
hide_loading_newer: noop,
});
set_global("document", "document-stub");
const message_fetch = zrequire("message_fetch");
const {all_messages_data} = zrequire("all_messages_data");
const {Filter} = zrequire("../src/filter");
const message_list = zrequire("message_list");
const people = zrequire("people");
const alice = {
email: "alice@example.com",
user_id: 7,
full_name: "Alice",
};
people.add_active_user(alice);
function make_home_msg_list() {
const filter = new Filter([]);
const list = new message_list.MessageList({
filter,
});
return list;
}
function reset_lists() {
message_lists.home = make_home_msg_list();
message_lists.current = message_lists.home;
all_messages_data.clear();
}
function config_fake_channel(conf) {
const self = {};
let called;
let called_with_newest_flag = false;
channel.get = (opts) => {
assert.equal(opts.url, "/json/messages");
// There's a separate call with anchor="newest" that happens
// unconditionally; do basic verification of that call.
if (opts.data.anchor === "newest") {
assert.ok(!called_with_newest_flag, "Only one 'newest' call allowed");
called_with_newest_flag = true;
assert.equal(opts.data.num_after, 0);
return;
}
assert.ok(!called || conf.can_call_again, "only use this for one call");
if (!conf.can_call_again) {
assert.equal(self.success, undefined);
}
assert.deepEqual(opts.data, conf.expected_opts_data);
self.success = opts.success;
called = true;
};
return self;
}
function config_process_results(messages) {
const self = {};
const messages_processed_for_new = [];
message_helper.process_new_message = (message) => {
messages_processed_for_new.push(message);
return message;
};
message_util.do_unread_count_updates = (arg) => {
assert.deepEqual(arg, messages);
};
message_util.add_old_messages = (new_messages, msg_list) => {
assert.deepEqual(new_messages, messages);
msg_list.add_messages(new_messages);
};
stream_list.update_streams_sidebar = noop;
self.verify = () => {
assert.deepEqual(messages_processed_for_new, messages);
};
return self;
}
function message_range(start, end) {
return _.range(start, end).map((idx) => ({
id: idx,
}));
}
const initialize_data = {
initial_fetch: {
req: {
anchor: "first_unread",
num_before: 200,
num_after: 200,
client_gravatar: true,
// Same as message_lists.home.data.public_terms() after `reset_lists` is called.
narrow: JSON.stringify([]),
},
resp: {
messages: message_range(201, 801),
found_newest: false,
anchor: 444,
},
},
forward_fill: {
req: {
anchor: "800",
num_before: 0,
num_after: 1000,
client_gravatar: true,
narrow: JSON.stringify([]),
},
resp: {
messages: message_range(800, 1000),
found_newest: true,
},
},
back_fill: {
req: {
anchor: "201",
num_before: 1000,
num_after: 0,
client_gravatar: true,
narrow: JSON.stringify([]),
},
resp: {
messages: message_range(100, 200),
found_oldest: true,
},
},
};
function test_fetch_success(opts) {
const response = opts.response;
const messages = response.messages;
const process_results = config_process_results(messages);
opts.fetch.success(response);
process_results.verify();
}
function initial_fetch_step(finished_initial_fetch) {
const self = {};
let fetch;
const response = initialize_data.initial_fetch.resp;
self.prep = () => {
fetch = config_fake_channel({
expected_opts_data: initialize_data.initial_fetch.req,
});
message_fetch.initialize(finished_initial_fetch);
};
self.finish = () => {
test_fetch_success({
fetch,
response,
});
};
return self;
}
function forward_fill_step() {
const self = {};
let fetch;
self.prep = () => {
/* Don't wait for the timeout before recursively calling `load_messages`. */
const expected_delay = 150;
set_global("setTimeout", (f, delay) => {
assert.equal(delay, expected_delay);
f();
});
fetch = config_fake_channel({
expected_opts_data: initialize_data.forward_fill.req,
});
};
self.finish = () => {
const response = initialize_data.forward_fill.resp;
let idle_config;
$("document-stub").idle = (config) => {
idle_config = config;
};
test_fetch_success({
fetch,
response,
});
assert.equal(idle_config.idle, 10000);
return idle_config;
};
return self;
}
function test_backfill_idle(idle_config) {
const fetch = config_fake_channel({
expected_opts_data: initialize_data.back_fill.req,
});
const response = initialize_data.back_fill.resp;
idle_config.onIdle();
test_fetch_success({
fetch,
response,
});
}
run_test("initialize", () => {
reset_lists();
let home_loaded = false;
page_params.unread_msgs = {
old_unreads_missing: false,
};
function finished_initial_fetch() {
home_loaded = true;
}
const step1 = initial_fetch_step(finished_initial_fetch);
step1.prep();
const step2 = forward_fill_step();
step2.prep();
step1.finish();
assert.ok(!home_loaded);
const idle_config = step2.finish();
assert.ok(home_loaded);
test_backfill_idle(idle_config);
});
function simulate_narrow() {
const filter = new Filter([{operator: "dm", operand: alice.email}]);
const msg_list = new message_list.MessageList({
filter,
});
message_lists.current = msg_list;
return msg_list;
}
run_test("loading_newer", () => {
function test_dup_new_fetch(msg_list) {
assert.equal(msg_list.data.fetch_status.can_load_newer_messages(), false);
message_fetch.maybe_load_newer_messages({
msg_list,
});
}
function test_happy_path(opts) {
const msg_list = opts.msg_list;
const data = opts.data;
const fetch = config_fake_channel({
expected_opts_data: data.req,
can_call_again: true,
});
message_fetch.maybe_load_newer_messages({
msg_list,
show_loading: noop,
hide_loading: noop,
});
test_dup_new_fetch(msg_list);
test_fetch_success({
fetch,
response: data.resp,
});
}
(function test_narrow() {
let msg_list = simulate_narrow();
page_params.unread_msgs = {
old_unreads_missing: true,
};
// Test what happens when an empty list is returned with found_newest false.
const empty_list_data = {
req: {
anchor: "oldest",
num_before: 0,
num_after: 100,
narrow: `[{"negated":false,"operator":"dm","operand":[${alice.user_id}]}]`,
client_gravatar: true,
},
resp: {
messages: message_range(500, 600),
found_newest: false,
},
};
test_happy_path({
msg_list,
data: empty_list_data,
});
msg_list = simulate_narrow();
msg_list.append_to_view = noop;
// Instead of using 444 as page_param.pointer, we
// should have a message with that id in the message_list.
msg_list.append(message_range(444, 445), false);
const data = {
req: {
anchor: "444",
num_before: 0,
num_after: 100,
narrow: `[{"negated":false,"operator":"dm","operand":[${alice.user_id}]}]`,
client_gravatar: true,
},
resp: {
messages: message_range(500, 600),
found_newest: false,
},
};
test_happy_path({
msg_list,
data,
});
assert.equal(msg_list.data.fetch_status.can_load_newer_messages(), true);
// The server successfully responded with messages having id's from 500-599.
// We test for the case that this was the last batch of messages for the narrow
// so no more fetching should occur.
// And also while fetching for the above condition the server received a new message
// event, updating the last message's id for that narrow to 600 from 599.
data.resp.found_newest = true;
msg_list.data.fetch_status.update_expected_max_message_id([{id: 600}]);
test_happy_path({
msg_list,
data,
});
// To handle this special case we should allow another fetch to occur,
// since the last message event's data had been discarded.
// This fetch goes on until the newest message has been found.
assert.equal(msg_list.data.fetch_status.can_load_newer_messages(), false);
})();
(function test_home() {
reset_lists();
let msg_list = message_lists.home;
// Test what happens when an empty list is returned with found_newest false.
const empty_list_data = {
req: {
anchor: "oldest",
num_before: 0,
num_after: 100,
client_gravatar: true,
narrow: JSON.stringify([]),
},
resp: {
messages: message_range(500, 600),
found_newest: false,
},
};
test_happy_path({
msg_list,
data: empty_list_data,
});
reset_lists();
const data = [
{
req: {
anchor: "444",
num_before: 0,
num_after: 100,
client_gravatar: true,
narrow: JSON.stringify([]),
},
resp: {
messages: message_range(500, 600),
found_newest: false,
},
},
{
req: {
anchor: "599",
num_before: 0,
num_after: 100,
client_gravatar: true,
narrow: JSON.stringify([]),
},
resp: {
messages: message_range(700, 800),
found_newest: true,
},
},
];
msg_list = message_lists.home;
all_messages_data.append(message_range(444, 445), false);
test_happy_path({
msg_list,
data: data[0],
});
assert.equal(msg_list.data.fetch_status.can_load_newer_messages(), true);
test_happy_path({
msg_list,
data: data[1],
});
assert.equal(msg_list.data.fetch_status.can_load_newer_messages(), false);
})();
});

11
web/tests/narrow_activate.test.js
View File

@@ -21,14 +21,6 @@ const compose_recipient = mock_esm("../src/compose_recipient");
const message_fetch = mock_esm("../src/message_fetch");
const message_list = mock_esm("../src/message_list");
const message_lists = mock_esm("../src/message_lists", {
home: {
view: {
$list: {
removeClass: noop,
addClass: noop,
},
},
},
current: {
view: {
$list: {
@@ -44,6 +36,9 @@ const message_lists = mock_esm("../src/message_lists", {
update_current_message_list(msg_list) {
message_lists.current = msg_list;
},
all_rendered_message_lists() {
return [message_lists.current];
},
});
const message_feed_top_notices = mock_esm("../src/message_feed_top_notices");
const message_feed_loading = mock_esm("../src/message_feed_loading");

7
web/tests/server_events.test.js
View File

@@ -10,18 +10,11 @@ const {page_params} = require("./lib/zpage_params");
set_global("addEventListener", noop);
const channel = mock_esm("../src/channel");
const message_lists = mock_esm("../src/message_lists");
mock_esm("../src/reload_state", {
is_in_progress() {
return false;
},
});
message_lists.home = {
select_id: noop,
selected_id() {
return 1;
},
};
page_params.test_suite = false;
// we also directly write to pointer

1
web/tests/transmit.test.js
View File

@@ -80,7 +80,6 @@ run_test("transmit_message_ajax_reload_pending", () => {
reload_initiated = true;
assert.deepEqual(opts, {
immediate: true,
save_pointer: true,
save_compose: true,
send_after_reload: true,
});