More tests

Author: dahlia

src/message-impl.test.ts

@@ -15,15 +15,26 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 import { MemoryKvStore } from "@fedify/fedify/federation";
 import {
+  Announce,
+  Create,
+  Delete,
   Hashtag,
   Mention,
   Note,
+  Person,
   PUBLIC_COLLECTION,
+  Tombstone,
+  Undo,
 } from "@fedify/fedify/vocab";
+import { assert } from "@std/assert/assert";
 import { assertEquals } from "@std/assert/equals";
+import { assertInstanceOf } from "@std/assert/instance-of";
 import { assertRejects } from "@std/assert/rejects";
 import { BotImpl } from "./bot-impl.ts";
 import { createMessage } from "./message-impl.ts";
+import { createMockContext } from "./session-impl.test.ts";
+import { SessionImpl } from "./session-impl.ts";
+import { text } from "./text.ts";
 
 Deno.test("createMessage()", async () => {
   const bot = new BotImpl<void>({ kv: new MemoryKvStore(), username: "bot" });
@@ -126,3 +137,173 @@ Deno.test("createMessage()", async () => {
   const unknownMessage = await createMessage<Note, void>(unknown, session);
   assertEquals(unknownMessage.visibility, "unknown");
 });
+
+Deno.test("MessageImpl.delete()", async () => {
+  const kv = new MemoryKvStore();
+  const bot = new BotImpl<void>({ kv, username: "bot" });
+  const ctx = createMockContext(bot, "https://example.com");
+  const session = new SessionImpl(bot, ctx);
+  const note = new Note({
+    id: new URL(
+      "https://example.com/ap/note/c1c792ce-a0be-4685-b396-e59e5ef8c788",
+    ),
+    content: "<p>Hello, world!</p>",
+    attribution: new URL("https://example.com/ap/actor/bot"),
+    to: PUBLIC_COLLECTION,
+    cc: new URL("https://example.com/ap/actor/bot/followers"),
+  });
+  const msg = await createMessage<Note, void>(note, session);
+  await kv.set(
+    bot.kvPrefixes.messages,
+    ["c1c792ce-a0be-4685-b396-e59e5ef8c788"],
+  );
+  await kv.set(
+    [...bot.kvPrefixes.messages, "c1c792ce-a0be-4685-b396-e59e5ef8c788"],
+    {
+      "@context": "https://www.w3.org/ns/activitystreams",
+      "type": "Create",
+      "id":
+        "https://example.com/ap/create/c1c792ce-a0be-4685-b396-e59e5ef8c788",
+      "actor": "https://example.com/ap/actor/bot",
+      "to": "https://www.w3.org/ns/activitystreams#Public",
+      "cc": "https://example.com/ap/actor/bot/followers",
+      object: await note.toJsonLd(),
+    },
+  );
+  await msg.delete();
+  assertEquals(await kv.get(bot.kvPrefixes.messages), []);
+  assertEquals(
+    await kv.get([
+      ...bot.kvPrefixes.messages,
+      "c1c792ce-a0be-4685-b396-e59e5ef8c788",
+    ]),
+    undefined,
+  );
+  assertEquals(ctx.sentActivities.length, 1);
+  const { recipients, activity } = ctx.sentActivities[0];
+  assertEquals(recipients, "followers");
+  assertInstanceOf(activity, Delete);
+  assertEquals(activity.actorId, ctx.getActorUri(bot.identifier));
+  assertEquals(activity.toIds, [PUBLIC_COLLECTION]);
+  assertEquals(activity.ccIds, [ctx.getFollowersUri(bot.identifier)]);
+  const tombstone = await activity.getObject();
+  assertInstanceOf(tombstone, Tombstone);
+  assertEquals(tombstone.id, note.id);
+});
+
+Deno.test("MessageImpl.reply()", async () => {
+  const kv = new MemoryKvStore();
+  const bot = new BotImpl<void>({ kv, username: "bot" });
+  const ctx = createMockContext(bot, "https://example.com");
+  const session = new SessionImpl(bot, ctx);
+  const originalPost = new Note({
+    id: new URL(
+      "https://example.com/ap/note/c1c792ce-a0be-4685-b396-e59e5ef8c788",
+    ),
+    content: "<p>Hello, world!</p>",
+    attribution: new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    }),
+    to: new URL("https://example.com/ap/actor/john/followers"),
+    cc: PUBLIC_COLLECTION,
+  });
+  const originalMsg = await createMessage<Note, void>(originalPost, session);
+  const reply = await originalMsg.reply(text`Hello, John!`);
+  const msgIds = await kv.get<string[]>(bot.kvPrefixes.messages);
+  assert(msgIds != null);
+  assertEquals(msgIds.length, 1);
+  const [msgId] = msgIds;
+  const activityJson = await kv.get([...bot.kvPrefixes.messages, msgId]);
+  assert(activityJson != null);
+  const create = await Create.fromJsonLd(activityJson);
+  assertEquals(ctx.sentActivities.length, 1);
+  const { recipients, activity } = ctx.sentActivities[0];
+  assertEquals(recipients, "followers");
+  assertInstanceOf(activity, Create);
+  assertEquals(
+    await activity.toJsonLd({ format: "compact" }),
+    await create.toJsonLd({ format: "compact" }),
+  );
+  assertEquals(
+    await reply.raw.toJsonLd({ format: "compact" }),
+    await (await create.getObject())?.toJsonLd({ format: "compact" }),
+  );
+  assertEquals(reply.actor, await session.getActor());
+  assertEquals(reply.replyTarget, originalMsg);
+  assertEquals(reply.visibility, "unlisted");
+});
+
+Deno.test("MessageImpl.share()", async (t) => {
+  const kv = new MemoryKvStore();
+  const bot = new BotImpl<void>({ kv, username: "bot" });
+  const ctx = createMockContext(bot, "https://example.com");
+  const session = new SessionImpl(bot, ctx);
+  const originalPost = new Note({
+    id: new URL(
+      "https://example.com/ap/note/c1c792ce-a0be-4685-b396-e59e5ef8c788",
+    ),
+    content: "<p>Hello, world!</p>",
+    attribution: new Person({
+      id: new URL("https://example.com/ap/actor/john"),
+      preferredUsername: "john",
+    }),
+    to: new URL("https://example.com/ap/actor/john/followers"),
+    cc: PUBLIC_COLLECTION,
+  });
+  const originalMsg = await createMessage<Note, void>(originalPost, session);
+  const sharedMsg = await originalMsg.share();
+  let msgId: string;
+
+  await t.step("share()", async () => {
+    const msgIds = await kv.get<string[]>(bot.kvPrefixes.messages);
+    assert(msgIds != null);
+    assertEquals(msgIds.length, 1);
+    [msgId] = msgIds;
+    const activityJson = await kv.get([...bot.kvPrefixes.messages, msgId]);
+    assert(activityJson != null);
+    const announce = await Announce.fromJsonLd(activityJson);
+    assertEquals(ctx.sentActivities.length, 1);
+    const { recipients, activity } = ctx.sentActivities[0];
+    assertEquals(recipients, "followers");
+    assertInstanceOf(activity, Announce);
+    assertEquals(activity.toIds, [ctx.getFollowersUri(bot.identifier)]);
+    assertEquals(activity.ccIds, [
+      PUBLIC_COLLECTION,
+      originalPost.attributionId,
+    ]);
+    assertEquals(
+      await activity.toJsonLd({ format: "compact" }),
+      await announce.toJsonLd({ format: "compact" }),
+    );
+    assertEquals(
+      await sharedMsg.raw.toJsonLd({ format: "compact" }),
+      await announce.toJsonLd({ format: "compact" }),
+    );
+    assertEquals(sharedMsg.actor, await session.getActor());
+    assertEquals(sharedMsg.visibility, "unlisted");
+    assertEquals(sharedMsg.original, originalMsg);
+  });
+
+  ctx.sentActivities = [];
+
+  await t.step("unshare()", async () => {
+    await sharedMsg.unshare();
+    assertEquals(await kv.get(bot.kvPrefixes.messages), []);
+    assertEquals(
+      await kv.get([...bot.kvPrefixes.messages, msgId]),
+      undefined,
+    );
+    assertEquals(ctx.sentActivities.length, 1);
+    const { recipients, activity } = ctx.sentActivities[0];
+    assertEquals(recipients, "followers");
+    assertInstanceOf(activity, Undo);
+    assertEquals(activity.actorId, ctx.getActorUri(bot.identifier));
+    assertEquals(activity.toIds, [ctx.getFollowersUri(bot.identifier)]);
+    assertEquals(activity.ccIds, [
+      PUBLIC_COLLECTION,
+      originalPost.attributionId,
+    ]);
+    assertEquals(activity.objectId, sharedMsg.id);
+  });
+});

src/message-impl.ts

@@ -231,7 +231,9 @@ export class MessageImpl<T extends MessageClass, TContextData>
         excludeBaseUris: [new URL(this.session.context.origin)],
       },
     );
-    const actor = await announce.getActor(this.session.context);
+    const actor = announce.actorId?.href === this.session.actorId.href
+      ? await this.session.getActor()
+      : await announce.getActor(this.session.context);
     if (actor == null) throw new TypeError("The actor is required.");
     return {
       raw: announce,
@@ -289,9 +291,9 @@ export async function createMessage<T extends MessageClass, TContextData>(
   session: SessionImpl<TContextData>,
   replyTarget?: Message<MessageClass, TContextData>,
 ): Promise<Message<T, TContextData>> {
-  if (raw.id == null) throw new TypeError(`The raw.id is required.`);
+  if (raw.id == null) throw new TypeError("The raw.id is required.");
   else if (raw.content == null) {
-    throw new TypeError(`The raw.content is required.`);
+    throw new TypeError("The raw.content is required.");
   }
   const documentLoader = await session.context.getDocumentLoader(session.bot);
   const options = {
@@ -303,7 +305,7 @@ export async function createMessage<T extends MessageClass, TContextData>(
     ? await session.getActor()
     : await raw.getAttribution(options);
   if (actor == null) {
-    throw new TypeError(`The raw.attributionId is required.`);
+    throw new TypeError("The raw.attributionId is required.");
   }
   const content = raw.content.toString();
   const text = textXss.process(content);

src/session-impl.test.ts

@@ -150,16 +150,16 @@ Deno.test("SessionImpl.publish()", async (t) => {
   });
 });
 
-interface SentActivity {
+export interface SentActivity {
   recipients: "followers" | Recipient[];
   activity: Activity;
 }
 
-interface MockContext extends Context<void> {
+export interface MockContext extends Context<void> {
   sentActivities: SentActivity[];
 }
 
-function createMockContext(
+export function createMockContext(
   bot: BotImpl<void>,
   origin: URL | string,
 ): MockContext {