@remit/data-ports 0.0.82 → 0.0.84

package/src/message-settlement.test.ts

@@ -1,132 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import {
-	MessageMutation,
-	MessageStatus,
-	MessageSyncStatus,
-} from "@remit/domain-enums";
-import {
-	abandonedMutationOf,
-	hasAbandonedDelete,
-	hasAbandonedMove,
-	type MessageSettlementFields,
-} from "./message-settlement.js";
-
-const row = (over: Partial<MessageSettlementFields>): MessageSettlementFields =>
-	({
-		status: MessageStatus.active,
-		syncStatus: MessageSyncStatus.synced,
-		abandonedMutation: MessageMutation.none,
-		...over,
-	}) as MessageSettlementFields;
-
-describe("abandonedMutationOf", () => {
-	test("names the delete `abandonDelete` gave up on", () => {
-		assert.equal(
-			abandonedMutationOf(
-				row({
-					syncStatus: MessageSyncStatus.abandoned,
-					abandonedMutation: MessageMutation.delete,
-				}),
-			),
-			MessageMutation.delete,
-		);
-	});
-
-	/**
-	 * Issue #1229: the two used to be one state on the wire, so a move that
-	 * handed back rendered the delete copy under a button that deleted the
-	 * message. The row has to say which, because the hand-back is what erased
-	 * the `status` that said it.
-	 */
-	test("names the move a hand-back gave up on, distinctly", () => {
-		assert.equal(
-			abandonedMutationOf(
-				row({
-					syncStatus: MessageSyncStatus.abandoned,
-					abandonedMutation: MessageMutation.move,
-				}),
-			),
-			MessageMutation.move,
-		);
-	});
-
-	test("`syncStatus` is the gate: a settled row's stale marker says nothing", () => {
-		assert.equal(
-			abandonedMutationOf(
-				row({
-					syncStatus: MessageSyncStatus.synced,
-					abandonedMutation: MessageMutation.delete,
-				}),
-			),
-			MessageMutation.none,
-		);
-	});
-
-	/**
-	 * `failed` is the transient attempt marker — every handler writes it and
-	 * re-throws for redelivery (imap-mutations R3) — so it can never mean a
-	 * give-up, whatever `status` sits beside it. This is issue #1153: before the
-	 * give-up had a value of its own, these three were the same row.
-	 */
-	for (const status of [
-		MessageStatus.active,
-		MessageStatus.moving,
-		MessageStatus.deleting,
-	]) {
-		test(`a ${status} row mid-retry is not a give-up`, () => {
-			assert.equal(
-				abandonedMutationOf(
-					row({ status, syncStatus: MessageSyncStatus.failed }),
-				),
-				MessageMutation.none,
-			);
-		});
-	}
-
-	test("an ordinary inbound row, `pending` forever, says nothing", () => {
-		assert.equal(
-			abandonedMutationOf(row({ syncStatus: MessageSyncStatus.pending })),
-			MessageMutation.none,
-		);
-	});
-
-	/**
-	 * A move or delete that exhausted its retries is repaired against IMAP and
-	 * now carries the give-up (#1098, #1005). What still lands on `synced` is a
-	 * hand-back that refused nothing — the server never heard the command — and
-	 * that is settled, not abandoned.
-	 */
-	test("`synced` is never a give-up, however it was reached", () => {
-		assert.equal(
-			abandonedMutationOf(row({ syncStatus: MessageSyncStatus.synced })),
-			MessageMutation.none,
-		);
-	});
-});
-
-describe("the per-operation predicates", () => {
-	const abandoned = (
-		mutation: MessageSettlementFields["abandonedMutation"],
-	): MessageSettlementFields =>
-		row({
-			syncStatus: MessageSyncStatus.abandoned,
-			abandonedMutation: mutation,
-		});
-
-	test("a delete that gave up is a delete and not a move", () => {
-		assert.equal(hasAbandonedDelete(abandoned(MessageMutation.delete)), true);
-		assert.equal(hasAbandonedMove(abandoned(MessageMutation.delete)), false);
-	});
-
-	test("a move that gave up is a move and not a delete", () => {
-		assert.equal(hasAbandonedMove(abandoned(MessageMutation.move)), true);
-		assert.equal(hasAbandonedDelete(abandoned(MessageMutation.move)), false);
-	});
-
-	test("a copy that gave up claims neither", () => {
-		const copy = abandoned(MessageMutation.copy);
-		assert.equal(hasAbandonedDelete(copy), false);
-		assert.equal(hasAbandonedMove(copy), false);
-	});
-});

package/src/sender-mute.test.ts

@@ -1,76 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { isSenderMuted, isSenderMuteFilter } from "./sender-mute.js";
-import type { FilterItem } from "./types.js";
-
-const rule = (overrides: Partial<FilterItem> = {}): FilterItem =>
-	({
-		scope: "Standing",
-		literalClauses: [{ field: "From", value: "ada@example.test" }],
-		actionLabelId: "None",
-		actionMailboxId: "None",
-		...overrides,
-	}) as unknown as FilterItem;
-
-describe("isSenderMuteFilter", () => {
-	it("recognises a standing rule that names a sender and does nothing", () => {
-		assert.equal(isSenderMuteFilter(rule()), true);
-	});
-
-	it("declines a rule that applies a label", () => {
-		assert.equal(isSenderMuteFilter(rule({ actionLabelId: "label-1" })), false);
-	});
-
-	it("declines a rule that moves the message", () => {
-		assert.equal(
-			isSenderMuteFilter(rule({ actionMailboxId: "mailbox-1" })),
-			false,
-		);
-	});
-
-	it("declines a rule that matches on something other than the sender", () => {
-		assert.equal(
-			isSenderMuteFilter(
-				rule({
-					literalClauses: [{ field: "Subject", value: "invitation" }],
-				} as Partial<FilterItem>),
-			),
-			false,
-		);
-	});
-
-	it("declines a rule with no clauses, which would mute everybody", () => {
-		assert.equal(isSenderMuteFilter(rule({ literalClauses: [] })), false);
-	});
-
-	it("declines a temporary rule", () => {
-		assert.equal(isSenderMuteFilter(rule({ scope: "Temporary" })), false);
-	});
-});
-
-describe("isSenderMuted", () => {
-	it("matches an address whatever case either side was written in", () => {
-		assert.equal(isSenderMuted([rule()], "Ada@Example.TEST"), true);
-	});
-
-	it("matches the whole address, never a substring of one", () => {
-		// A rule about ada@example.test must not silence an address that merely
-		// contains it — the lookalike is exactly what a spoofer would send from.
-		assert.equal(
-			isSenderMuted([rule()], "not-ada@example.test.evil.test"),
-			false,
-		);
-	});
-
-	it("says no when nothing names the sender", () => {
-		assert.equal(isSenderMuted([rule()], "someone@example.test"), false);
-	});
-
-	it("says no for an empty sender rather than matching an empty clause", () => {
-		assert.equal(isSenderMuted([rule()], ""), false);
-	});
-
-	it("says no with no rules at all", () => {
-		assert.equal(isSenderMuted([], "ada@example.test"), false);
-	});
-});