Spaces:
Running
Running
| """/sequence (collect files) and /sort (send them back in episode order, then report gaps and repeats).""" | |
| import asyncio | |
| import time | |
| import pytest | |
| from telethon import errors | |
| from bot import app as appmod | |
| from .appkit import ADMIN_CFG, OWNER, STRANGER, click, data_of, say, send_doc | |
| OP = "{n} - One Piece [Dual] 720p @Anime_X_Universe.mkv" | |
| def quick(monkeypatch): | |
| monkeypatch.setattr(appmod, "SEQUENCE_STATUS_DELAY", 0.02) | |
| monkeypatch.setattr(appmod, "SORT_GAP", 0) | |
| monkeypatch.setattr(appmod, "SORT_SLOW_GAP", 0) | |
| async def settle(delay=0.12): | |
| await asyncio.sleep(delay) | |
| async def feed(ctx, numbers, uid=OWNER, first_id=100): | |
| """Send One Piece episodes in this order; returns {episode: message id} (the last id wins for repeats).""" | |
| ids = {} | |
| for k, n in enumerate(numbers): | |
| await send_doc(ctx, uid, OP.format(n=n), mid=first_id + k) | |
| ids[n] = first_id + k | |
| return ids | |
| def sent_ids(ctx, uid=OWNER): | |
| return [f.id for entity, f, _kw in ctx.client.files if entity == uid] | |
| def texts(ctx): | |
| return [t for _e, t, _k in ctx.client.sent] | |
| def last_text(ctx): | |
| return ctx.client.sent[-1][1] | |
| # --------------------------------------------------------------------------- | |
| # collecting | |
| # --------------------------------------------------------------------------- | |
| async def test_sequence_asks_for_files_and_collects_them_instead_of_renaming(ctx): | |
| ev = await say(ctx, OWNER, "/sequence") | |
| assert "SEQUENCE" in ev.texts[0] and "/sort" in ev.texts[0] and data_of(ev.out[0][1]) == ["sq:cx"] | |
| assert ctx.app.modes[OWNER].kind == "sequence" | |
| for k, n in enumerate((1147, 1145, 1146)): | |
| got = await send_doc(ctx, OWNER, OP.format(n=n), mid=100 + k) | |
| assert got.out == [] # nothing is queued, nothing is said per file | |
| assert ctx.app.queue.waiting == 0 and ctx.app.queue.running == 0 | |
| assert [i.msg_id for i in ctx.app.modes[OWNER].data.items] == [100, 101, 102] | |
| async def test_one_status_message_follows_each_burst_of_files_and_replaces_the_last(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1, 2, 3)) | |
| await settle() | |
| (status,) = [(t, k) for _e, t, k in ctx.client.sent if "collected" in t] | |
| assert "3 files collected" in status[0] and "/sort" in status[0] | |
| assert data_of(status[1]["buttons"]) == ["sq:sort", "sq:cx"] | |
| assert ctx.client.deleted == [] | |
| await send_doc(ctx, OWNER, OP.format(n=4), mid=200) | |
| await settle() | |
| assert [t for t in texts(ctx) if "collected" in t][-1].startswith("📥 <b>4 files collected") | |
| assert ctx.client.deleted == [(OWNER, [2001])] # the old status goes, so the newest one is at the bottom | |
| async def test_a_second_sequence_command_keeps_the_files_already_collected(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1, 2)) | |
| ev = await say(ctx, OWNER, "/sequence") | |
| assert "already collecting" in ev.texts[0] and "2 files collected" in ev.texts[0] and data_of(ev.out[0][1]) == ["sq:sort", "sq:cx"] | |
| assert len(ctx.app.modes[OWNER].data.items) == 2 | |
| async def test_the_limit_is_announced_once_and_extra_files_are_ignored(ctx, monkeypatch): | |
| monkeypatch.setattr(appmod, "SEQUENCE_MAX", 3) | |
| await say(ctx, OWNER, "/sequence") | |
| replies = [] | |
| for k in range(6): | |
| replies += (await send_doc(ctx, OWNER, OP.format(n=k + 1), mid=100 + k)).texts | |
| assert len(ctx.app.modes[OWNER].data.items) == 3 | |
| assert len(replies) == 1 and "limit: 3 files" in replies[0] | |
| await settle() | |
| assert "3 files collected" in texts(ctx)[-1] and "most I can sort" in texts(ctx)[-1] | |
| async def test_a_thousand_files_can_be_collected_and_the_next_one_is_refused(ctx): | |
| assert appmod.SEQUENCE_MAX == 1000 | |
| ev = await say(ctx, OWNER, "/sequence") | |
| assert "up to 1000" in ev.texts[0] | |
| replies = [] | |
| for k in range(1001): | |
| replies += (await send_doc(ctx, OWNER, OP.format(n=k + 1), mid=100 + k)).texts | |
| assert len(ctx.app.modes[OWNER].data.items) == 1000 | |
| assert len(replies) == 1 and "limit: 1000 files" in replies[0] | |
| await settle() | |
| assert "1000 files collected" in texts(ctx)[-1] and "most I can sort at once (1000)" in texts(ctx)[-1] | |
| async def test_every_user_has_their_own_sequence(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await say(ctx, ADMIN_CFG, "/sequence") | |
| await feed(ctx, (3, 1, 2), uid=OWNER, first_id=100) | |
| await feed(ctx, (9, 8), uid=ADMIN_CFG, first_id=500) | |
| await say(ctx, ADMIN_CFG, "/sort") | |
| assert sent_ids(ctx, ADMIN_CFG) == [501, 500] and sent_ids(ctx, OWNER) == [] | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx, OWNER) == [101, 102, 100] | |
| async def test_strangers_cannot_start_a_sequence(ctx): | |
| ev = await say(ctx, STRANGER, "/sequence") | |
| assert ev.out == [] and STRANGER not in ctx.app.modes | |
| # --------------------------------------------------------------------------- | |
| # /sort | |
| # --------------------------------------------------------------------------- | |
| async def test_sort_sends_the_files_back_in_ascending_episode_order(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| ids = await feed(ctx, (1147, 1145, 1148, 1146)) | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [ids[1145], ids[1146], ids[1147], ids[1148]] | |
| assert OWNER not in ctx.app.modes | |
| assert "Sorted 4 files" in last_text(ctx) and "E1145 → E1148" in last_text(ctx) and "No missing or repeated episodes." in last_text(ctx) | |
| async def test_sort_reports_missing_and_repeated_episodes_after_the_files(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1147, 1145, 1149, 1146, 1146, 1152)) | |
| await say(ctx, OWNER, "/sort") | |
| assert len(sent_ids(ctx)) == 6 | |
| report = last_text(ctx) | |
| assert "Sorted 6 files" in report and "E1145 → E1152" in report | |
| assert "Missing episodes</b>\nE1148, E1150–E1151" in report | |
| assert "Repeated episodes" in report and "E1146 ×2" in report | |
| assert "No missing or repeated" not in report | |
| assert ctx.client.sent[-1][2]["parse_mode"] == "html" | |
| async def test_files_without_an_episode_number_are_sent_last_and_listed(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await send_doc(ctx, OWNER, "notes.mkv", mid=100) | |
| await send_doc(ctx, OWNER, OP.format(n=2), mid=101) | |
| await send_doc(ctx, OWNER, OP.format(n=1), mid=102) | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [102, 101, 100] | |
| assert "No episode number found" in last_text(ctx) and "notes.mkv" in last_text(ctx) | |
| async def test_captions_and_their_formatting_travel_with_each_file(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await send_doc(ctx, OWNER, OP.format(n=2), mid=100, caption="Episode two <b>bold</b>") | |
| await send_doc(ctx, OWNER, OP.format(n=1), mid=101) | |
| ctx.client.messages[100].entities = ["BOLD-ENTITY"] | |
| await say(ctx, OWNER, "/sort") | |
| (_e1, first, kw1), (_e2, second, kw2) = ctx.client.files | |
| assert (first.id, second.id) == (101, 100) | |
| assert kw1["caption"] == "" and kw2["caption"] == "Episode two <b>bold</b>" | |
| assert kw2["formatting_entities"] == ["BOLD-ENTITY"] and kw2["parse_mode"] is None # the text is not parsed a second time | |
| async def test_sort_fetches_the_messages_again_so_old_file_references_still_work(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (2, 1, 3)) | |
| await say(ctx, OWNER, "/sort") | |
| (chat, ids), = ctx.client.get_calls | |
| assert chat == OWNER and sorted(ids) == [100, 101, 102] and ids == [101, 100, 102] | |
| async def test_sort_looks_the_files_up_a_hundred_at_a_time_and_keeps_the_order(ctx): | |
| # One request for more than 300 ids makes Telethon wait 10 s between its chunks of 100: with a thousand files that is | |
| # a minute and a half of nothing before the first file arrives. Looking them up as the sort goes avoids it. | |
| await say(ctx, OWNER, "/sequence") | |
| at = await feed(ctx, range(250, 0, -1)) # newest first; at[episode] is its message id | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [at[n] for n in range(1, 251)] | |
| assert [len(asked) for _chat, asked in ctx.client.get_calls] == [100, 100, 50] | |
| assert [asked[0] for _chat, asked in ctx.client.get_calls] == [at[1], at[101], at[201]] | |
| assert "Sorted 250 files" in last_text(ctx) and "E01 → E250" in last_text(ctx) and "No missing or repeated" in last_text(ctx) | |
| async def test_lookups_follow_the_sending_instead_of_all_coming_first(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, range(1, 151)) | |
| sent_so_far = [] | |
| original = ctx.client.get_messages | |
| async def lookup(entity, ids=None, **kw): | |
| sent_so_far.append(len(ctx.client.files)) | |
| return await original(entity, ids=ids, **kw) | |
| ctx.client.get_messages = lookup | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_so_far == [0, 100] # the second hundred is looked up once the first hundred is out | |
| async def test_a_chunk_that_cannot_be_looked_up_is_listed_and_the_rest_still_arrives(ctx, caplog): | |
| await say(ctx, OWNER, "/sequence") | |
| at = await feed(ctx, range(1, 251)) | |
| original = ctx.client.get_messages | |
| async def flaky(entity, ids=None, **kw): | |
| if ids[0] == at[101]: # the second chunk: episodes 101-200 | |
| raise RuntimeError("MESSAGE_ID_INVALID") | |
| return await original(entity, ids=ids, **kw) | |
| ctx.client.get_messages = flaky | |
| with caplog.at_level("ERROR"): | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [at[n] for n in (*range(1, 101), *range(201, 251))] | |
| report = last_text(ctx) | |
| assert "Sorted 150 of 250 files" in report and "Couldn't be sent" in report and "… and 88 more" in report | |
| assert any("could not look up 100 files" in r.getMessage() for r in caplog.records) # the log channel hears about it | |
| assert OWNER not in ctx.app._sorting | |
| async def test_the_rename_mode_decides_where_the_episode_is_read_from(ctx): | |
| await say(ctx, OWNER, "/mode caption") | |
| await say(ctx, OWNER, "/sequence") | |
| await send_doc(ctx, OWNER, "video.mkv", mid=100, caption="One Piece - 1147") | |
| await send_doc(ctx, OWNER, "other.mkv", mid=101, caption="One Piece - 1145") | |
| await send_doc(ctx, OWNER, "clip.mkv", mid=102, caption="One Piece - 1146") | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [101, 102, 100] | |
| assert "E1145 → E1147" in last_text(ctx) | |
| async def test_sort_with_nothing_collected_explains_how_it_works(ctx): | |
| for _ in range(2): | |
| await say(ctx, OWNER, "/sort") | |
| assert "Nothing to sort yet" in last_text(ctx) and "/sequence" in last_text(ctx) | |
| await say(ctx, OWNER, "/sequence") # started but empty: still nothing to sort | |
| assert ctx.client.files == [] | |
| async def test_after_a_sort_files_are_renamed_as_usual_again(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1, 2)) | |
| await say(ctx, OWNER, "/sort") | |
| ev = await send_doc(ctx, OWNER, OP.format(n=3), mid=300) | |
| assert "Queued" in ev.texts[0] and ctx.app.queue.waiting == 1 | |
| # and a new sequence starts from scratch | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (7,), first_id=400) | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx)[-1] == 400 and "Sorted 1 file" in last_text(ctx) | |
| async def test_a_sequence_that_nobody_finished_is_forgotten_after_its_time(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1, 2)) | |
| ctx.app.modes[OWNER].expires = time.time() - 1 | |
| await say(ctx, OWNER, "/sort") | |
| assert "Nothing to sort yet" in last_text(ctx) and ctx.client.files == [] | |
| ev = await send_doc(ctx, OWNER, OP.format(n=3), mid=300) | |
| assert "Queued" in ev.texts[0] | |
| async def test_every_new_file_gives_the_sequence_more_time(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| mode = ctx.app.modes[OWNER] | |
| mode.expires = time.time() + 5 | |
| await feed(ctx, (1,)) | |
| assert mode.expires > time.time() + appmod.SEQUENCE_WAIT - 60 | |
| async def test_the_status_message_is_removed_and_a_progress_message_replaces_it(ctx, monkeypatch): | |
| monkeypatch.setattr(appmod, "SORT_PROGRESS_EVERY", 2) | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (5, 4, 3, 2, 1)) | |
| await settle() | |
| status_id = [2000 + i + 1 for i, (_e, t, _k) in enumerate(ctx.client.sent) if "collected" in t][-1] | |
| await say(ctx, OWNER, "/sort") | |
| assert (OWNER, [status_id]) in ctx.client.deleted | |
| progress = [t for _c, t, _k in ctx.client.edited] | |
| assert progress == ["🔢 <b>Sorting…</b> 2 of 5 sent", "🔢 <b>Sorting…</b> 4 of 5 sent"] | |
| sorting_id = [2000 + i + 1 for i, (_e, t, _k) in enumerate(ctx.client.sent) if "Sorting 5 files" in t][0] | |
| assert (OWNER, [sorting_id]) in ctx.client.deleted # the progress message goes before the report | |
| # --------------------------------------------------------------------------- | |
| # buttons | |
| # --------------------------------------------------------------------------- | |
| async def test_the_sort_button_does_the_same_as_the_command(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (3, 1, 2)) | |
| cb = await click(ctx, OWNER, "sq:sort") | |
| assert cb.answers and sent_ids(ctx) == [101, 102, 100] and "Sorted 3 files" in last_text(ctx) | |
| async def test_the_discard_button_throws_the_files_away(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (3, 1)) | |
| cb = await click(ctx, OWNER, "sq:cx") | |
| assert "2 files discarded" in cb.edits[-1][0] and cb.edits[-1][1] == [] | |
| assert OWNER not in ctx.app.modes | |
| await say(ctx, OWNER, "/sort") | |
| assert "Nothing to sort yet" in last_text(ctx) | |
| async def test_old_buttons_say_the_sequence_is_over(ctx): | |
| for data in ("sq:sort", "sq:cx"): | |
| cb = await click(ctx, OWNER, data) | |
| assert cb.alerts == ["That sequence is over."] | |
| assert ctx.client.files == [] and ctx.client.sent == [] | |
| # --------------------------------------------------------------------------- | |
| # /cancel | |
| # --------------------------------------------------------------------------- | |
| async def test_cancel_discards_the_collected_files(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (2, 1)) | |
| await settle() | |
| status_id = 2001 # the "2 files collected" message | |
| before = len([t for t in texts(ctx) if "collected" in t]) | |
| ev = await say(ctx, OWNER, "/cancel") | |
| assert "Sequence cancelled" in ev.texts[0] and "2 files discarded" in ev.texts[0] | |
| assert (OWNER, [status_id]) in ctx.client.deleted # its buttons would be dead, so it goes | |
| await say(ctx, OWNER, "/sort") | |
| assert "Nothing to sort yet" in last_text(ctx) | |
| await settle() | |
| assert len([t for t in texts(ctx) if "collected" in t]) == before == 1 # no new status after the cancel | |
| ev = await send_doc(ctx, OWNER, OP.format(n=1), mid=300) | |
| assert "Queued" in ev.texts[0] | |
| async def test_cancel_leaves_queued_jobs_for_the_next_cancel(ctx): | |
| await send_doc(ctx, OWNER, OP.format(n=9), mid=50) | |
| assert ctx.app.queue.waiting == 1 | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (2,)) | |
| ev = await say(ctx, OWNER, "/cancel") | |
| assert "Sequence cancelled" in ev.texts[0] and "/cancel again" in ev.texts[0] and ctx.app.queue.waiting == 1 | |
| ev = await say(ctx, OWNER, "/cancel") | |
| assert "Cancelling 1 job" in ev.texts[0] | |
| async def test_cancel_stops_a_sort_that_is_sending(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (5, 4, 3, 2, 1)) | |
| gate = asyncio.Event() | |
| original = ctx.client.send_file | |
| calls = [] | |
| async def slow(entity, file, **kw): | |
| calls.append(file.id) | |
| if len(calls) == 2: | |
| await gate.wait() | |
| return await original(entity, file, **kw) | |
| ctx.client.send_file = slow | |
| sorting = asyncio.ensure_future(say(ctx, OWNER, "/sort")) | |
| await settle(0.05) | |
| assert calls == [104, 103] # episode 1, then 2 is in flight | |
| again = await say(ctx, OWNER, "/sort") # a second /sort while one is running | |
| assert again.out == [] and "still sorting" in last_text(ctx) | |
| ev = await say(ctx, OWNER, "/cancel") | |
| assert "Stopping the sort" in ev.texts[0] | |
| gate.set() | |
| await sorting | |
| assert sent_ids(ctx) == [104, 103] and "Stopped after 2 of 5 files" in last_text(ctx) | |
| assert "Sorted" not in last_text(ctx) and OWNER not in ctx.app._sorting | |
| # --------------------------------------------------------------------------- | |
| # things going wrong while sending | |
| # --------------------------------------------------------------------------- | |
| async def test_a_short_flood_wait_is_waited_out_and_the_file_is_sent_again(ctx): | |
| slept = [] | |
| async def pause(seconds): | |
| slept.append(seconds) | |
| ctx.app._pause = pause | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (2, 1, 3)) | |
| ctx.client.file_errors[100] = [errors.FloodWaitError(None, 90)] | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [101, 100, 102] and slept == [91] | |
| assert "Sorted 3 files" in last_text(ctx) and "Couldn't be sent" not in last_text(ctx) | |
| async def test_a_long_batch_goes_at_about_one_file_a_second_after_the_first_ones(ctx, monkeypatch): | |
| monkeypatch.setattr(appmod, "SORT_GAP", 0.1) | |
| monkeypatch.setattr(appmod, "SORT_SLOW_GAP", 0.5) | |
| monkeypatch.setattr(appmod, "SORT_FAST_FILES", 3) | |
| paused = [] | |
| async def pause(seconds): | |
| paused.append(seconds) | |
| ctx.app._pause = pause | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, range(1, 7)) | |
| await say(ctx, OWNER, "/sort") | |
| assert paused == [0.1, 0.1, 0.5, 0.5, 0.5, 0.5] # files 2 and 3 follow quickly, the rest wait their turn | |
| assert "Sorted 6 files" in last_text(ctx) | |
| async def test_a_very_long_flood_wait_stops_the_sort_and_lists_what_was_not_sent(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (4, 3, 2, 1)) | |
| ctx.client.file_errors[102] = [errors.FloodWaitError(None, 3600)] # episode 2 | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [103] # episode 1 went out, the wait hit at episode 2 | |
| report = last_text(ctx) | |
| assert "Sorted 1 of 4 files" in report and "wait 1h 0m 0s" in report and "Couldn't be sent" in report | |
| assert report.count(OP.format(n=2)[:20]) >= 1 and OP.format(n=4)[:4] in report | |
| async def test_a_status_that_is_still_being_sent_when_sort_starts_is_cleaned_up(ctx): | |
| original = ctx.client.send_message | |
| release = asyncio.Event() | |
| async def slow_status(entity, text="", **kw): | |
| if "collected" in text: | |
| await release.wait() | |
| return await original(entity, text, **kw) | |
| ctx.client.send_message = slow_status | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (2, 1)) | |
| await settle() # the status message is on its way, not sent yet | |
| await say(ctx, OWNER, "/sort") | |
| release.set() | |
| await settle() | |
| collected = [i + 1 + 2000 for i, (_e, t, _k) in enumerate(ctx.client.sent) if "collected" in t] | |
| assert len(collected) == 1 and (OWNER, collected) in ctx.client.deleted | |
| assert "Sorted 2 files" in last_text(ctx) or sent_ids(ctx) == [101, 100] | |
| async def test_a_file_that_fails_is_listed_and_the_others_still_arrive(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (3, 2, 1)) | |
| ctx.client.file_errors[101] = [RuntimeError("MEDIA_EMPTY")] # episode 2 | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [102, 100] | |
| report = last_text(ctx) | |
| assert "Sorted 2 of 3 files" in report and "Couldn't be sent" in report and "2 - One Piece" in report | |
| async def test_a_file_deleted_before_sorting_is_listed_not_fatal(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (3, 2, 1)) | |
| del ctx.client.messages[101] | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [102, 100] | |
| assert "Sorted 2 of 3 files" in last_text(ctx) and "Couldn't be sent" in last_text(ctx) | |
| assert OWNER not in ctx.app._sorting | |
| async def test_sort_that_blows_up_does_not_leave_the_user_locked_out(ctx, monkeypatch): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (2, 1)) | |
| def boom(*a, **kw): | |
| raise RuntimeError("something nobody expected") | |
| original = appmod.analyse | |
| monkeypatch.setattr(appmod, "analyse", boom) | |
| ev = await say(ctx, OWNER, "/sort") | |
| assert "Something went wrong" in ev.texts[-1] and OWNER not in ctx.app._sorting | |
| monkeypatch.setattr(appmod, "analyse", original) | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1,), first_id=300) | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [300] | |
| async def test_when_telegram_cannot_look_the_files_up_the_user_gets_a_report_and_is_not_locked_out(ctx): | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (2, 1)) | |
| async def boom(*a, **kw): | |
| raise RuntimeError("telegram is down") | |
| original, ctx.client.get_messages = ctx.client.get_messages, boom | |
| await say(ctx, OWNER, "/sort") | |
| assert ctx.client.files == [] and OWNER not in ctx.app._sorting | |
| report = last_text(ctx) | |
| assert "Sorted 0 of 2 files" in report and "Couldn't be sent" in report and "1 - One Piece" in report | |
| ctx.client.get_messages = original | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1,), first_id=300) | |
| await say(ctx, OWNER, "/sort") | |
| assert sent_ids(ctx) == [300] | |
| # --------------------------------------------------------------------------- | |
| # other commands that wait for a file | |
| # --------------------------------------------------------------------------- | |
| async def test_starting_a_rename_ends_the_sequence_and_says_so(ctx): | |
| fmt = await ctx.db.create_format(OWNER, "One Piece") | |
| await say(ctx, OWNER, "/sequence") | |
| await feed(ctx, (1, 2)) | |
| cb = await click(ctx, OWNER, f"rn:p:{fmt['id']}") | |
| assert "One Piece" in cb.edits[-1][0] and "2 file(s) was discarded" in cb.edits[-1][0] | |
| assert ctx.app.modes[OWNER].kind == "rename" | |
| await settle() | |
| assert [t for t in texts(ctx) if "collected" in t] == [] | |
| async def test_a_rename_with_no_sequence_has_no_such_note(ctx): | |
| fmt = await ctx.db.create_format(OWNER, "One Piece") | |
| cb = await click(ctx, OWNER, f"rn:p:{fmt['id']}") | |
| assert "discarded" not in cb.edits[-1][0] | |
| async def test_starting_a_sequence_over_a_rename_session_replaces_it(ctx): | |
| fmt = await ctx.db.create_format(OWNER, "One Piece") | |
| await click(ctx, OWNER, f"rn:p:{fmt['id']}") | |
| ev = await say(ctx, OWNER, "/sequence") | |
| assert "discarded" not in ev.texts[0] and ctx.app.modes[OWNER].kind == "sequence" | |
| await send_doc(ctx, OWNER, OP.format(n=1), mid=100) | |
| assert ctx.app.queue.waiting == 0 # collected, not renamed | |