@firedrill-tools/linkedin 0.1.1

package/test/flows/orgs.mjs

@@ -0,0 +1,107 @@
+// Organization, page role, network size, connection and feed flows.
+import assert from "node:assert/strict";
+import { enc, get, op, orgUrn, personUrn } from "../client.mjs";
+import { ORGS, PEOPLE, POSTS } from "../fixtures.mjs";
+
+const maya = personUrn(PEOPLE.maya);
+
+async function organizations() {
+  const org = (await get(`/rest/organizations/${ORGS.northwind}`)).body;
+  assert.equal(org.$URN, orgUrn(ORGS.northwind));
+  assert.equal(org.localizedName, "Northwind Analytics");
+  assert.equal(org.staffCountRange, "SIZE_51_TO_200");
+  assert.equal(org.locations[0].address.postalCode, "94607");
+  assert.equal(org.foundedOn.year, 2016);
+  assert.match(org.description.localized.en_US, /data platforms/);
+  const denied = (await get(`/rest/organizations/${ORGS.lakeview}`, [403, "ACCESS_DENIED"])).body;
+  assert.equal(denied.message, `Viewer don't have permission to the ADMIN_ONLY VisibilityReduction for urn:li:organization:${ORGS.lakeview}`);
+  await get(`/rest/organizations/${ORGS.brightline}`, [403, "ACCESS_DENIED"]);
+  assert.equal((await get("/rest/organizations/99999999", [404, "NOT_FOUND"])).body.message, "Organization 99999999 is inactive");
+  await get("/rest/organizations/abc", [400, "BAD_REQUEST"]);
+
+  const byVanity = (await get("/rest/organizations?q=vanityName&vanityName=Northwind-Analytics")).body;
+  assert.equal(byVanity.paging.total, 1);
+  assert.equal(byVanity.elements[0].id, ORGS.northwind);
+  assert.equal(byVanity.elements[0].description, undefined);
+  assert.deepEqual((await get("/rest/organizations?q=vanityName&vanityName=nobody-here")).body, {
+    paging: { start: 0, count: 10, links: [], total: 0 }, elements: [] });
+  await get("/rest/organizations?q=vanityName&vanityName=north%20wind", [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get("/rest/organizations?q=vanityName&vanityName=%ZZ", [400]);
+  await get("/rest/organizations?q=parentOrganization&vanityName=x", [400, "BAD_REQUEST"]);
+}
+
+async function acls() {
+  const mine = (await get("/rest/organizationAcls?q=roleAssignee")).body;
+  assert.equal(mine.paging.total, 3);
+  assert.ok(mine.elements.every((acl) => acl.roleAssignee === maya && acl.organization !== undefined));
+  assert.equal((await get("/rest/organizationAcls?q=roleAssignee&role=ADMINISTRATOR&state=APPROVED")).body.paging.total, 1);
+  const paged = (await get("/rest/organizationAcls?q=roleAssignee&count=1")).body;
+  assert.equal(paged.elements.length, 1);
+  assert.equal(paged.paging.links[0].rel, "next");
+  const target = (await get(`/rest/organizationAcls?q=organization&organization=${enc(orgUrn(ORGS.northwind))}`)).body;
+  assert.equal(target.paging.total, 3);
+  assert.ok(target.elements.every((acl) => acl.organizationTarget === orgUrn(ORGS.northwind) && acl.organization === undefined));
+  assert.ok(target.elements.some((acl) => acl.state === "REVOKED"));
+  await get(`/rest/organizationAcls?q=organization&organization=${enc(orgUrn(ORGS.brightline))}`, [403, "ACCESS_DENIED"]);
+  await get(`/rest/organizationAcls?q=organization&organization=${enc(orgUrn(99999999))}`, [404, "NOT_FOUND"]);
+  await get("/rest/organizationAcls?q=organization", [400, "MISSING_FIELD"]);
+  await get("/rest/organizationAcls?q=roleAssignee&role=OWNER", [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(`/rest/organizationAcls?q=organization&organization=${enc(maya)}`, [400, "INVALID_URN_TYPE"]);
+  await get("/rest/organizationAcls?q=organization&organization=urn%3Ali%3Aorganization%3A0", [400, "INVALID_URN_ID"]);
+}
+
+async function network() {
+  const followers = `/rest/networkSizes/${enc(orgUrn(ORGS.northwind))}`;
+  assert.deepEqual((await get(`${followers}?edgeType=COMPANY_FOLLOWED_BY_MEMBER`)).body, { firstDegreeSize: 4821 });
+  await get(`${followers}?edgeType=CompanyFollowedByMember`, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(followers, [400, "MISSING_FIELD"]);
+  await get(`/rest/networkSizes/${enc(orgUrn(99999999))}?edgeType=COMPANY_FOLLOWED_BY_MEMBER`, [404, "NOT_FOUND"]);
+  await get(`/rest/networkSizes/${enc("urn:li:share:1")}`, [400, "BAD_REQUEST"]);
+  assert.deepEqual((await get(`/v2/connections/${enc(maya)}`)).body, { firstDegreeSize: 7 });
+  await get(`/v2/connections/${enc(personUrn(PEOPLE.sam))}`, 403);
+  await op("network_sizes.get", { entity: "urn:li:share:1" }, "INVALID_URN_TYPE");
+  await op("network_sizes.get", { entity: "urn:li:person:x" }, "INVALID_URN_ID");
+
+  const page = async (start) => (await op("connections.list", { start, count: 3 })).value;
+  const pages = [await page(0), await page(3), await page(6)];
+  assert.equal(pages[0].paging.total, 7);
+  const names = pages.flatMap((p) => p.elements.map((e) => e.person.localizedFirstName));
+  assert.deepEqual(names, ["Grace", "Aiko", "Daniel", "Zoë", "Luis", "Priya", "Sam"]);
+  assert.deepEqual((await op("connections.list", { query: "ZOË" })).value.elements.map((e) => e.person.id), [PEOPLE.zoe]);
+  assert.deepEqual((await op("connections.list", { query: "data engineer" })).value.elements.map((e) => e.person.id), [PEOPLE.daniel]);
+  await op("connections.list", { query: "�" }, "INVALID_VALUE_FOR_FIELD");
+  await op("connections.list", { count: 101 }, "INVALID_VALUE_FOR_FIELD");
+}
+
+async function feed() {
+  const all = (await op("feed.list", { count: 50 })).value;
+  assert.equal(all.paging.total, 16);
+  assert.equal(all.viewer.connectionCount, 7);
+  assert.deepEqual(all.viewer.pages.map((p) => [p.name, p.roles]), [["Northwind Analytics", ["ADMINISTRATOR"]],
+    ["Lakeview Institute of Technology", ["ANALYST"]]]);
+  const ids = all.elements.map((item) => item.post.id);
+  for (const key of ["zoe", "sam", "brightline", "northwindArticle", "northwindPriya", "mayaConnections"]) assert.ok(ids.includes(POSTS[key].urn), key);
+  for (const key of ["jordan", "mayaDraft", "mayaDeleted"]) assert.ok(!ids.includes(POSTS[key].urn), key);
+  for (let i = 1; i < all.elements.length; i += 1) assert.ok(all.elements[i - 1].post.publishedAt >= all.elements[i].post.publishedAt);
+  const byId = new Map(all.elements.map((item) => [item.post.id, item]));
+  assert.equal(byId.get(POSTS.mayaReshare.urn).reshareOf.post.id, POSTS.sam.urn);
+  assert.equal(byId.get(POSTS.sam.urn).viewerReaction, "LIKE");
+  assert.equal(byId.get(POSTS.sam.urn).social.repostCount, 1);
+  assert.deepEqual(byId.get(POSTS.mayaArticle.urn).social.commentSummary, { count: 5, topLevelCount: 3 });
+  assert.deepEqual(byId.get(POSTS.northwindArticle.urn).actor, { urn: orgUrn(ORGS.northwind), kind: "organization", name: "Northwind Analytics",
+    headline: null, vanityName: "northwind-analytics" });
+  const first = (await op("feed.list", { count: 5 })).value;
+  assert.equal(first.elements.length, 5);
+  assert.equal(first.paging.links[0].rel, "next");
+  await op("feed.list", { count: 51 }, "INVALID_VALUE_FOR_FIELD");
+}
+
+async function orgsConnection() {
+  const target = (await get(`/rest/organizationAcls?q=organization&organization=${enc(orgUrn(ORGS.brightline))}`)).body;
+  assert.equal(target.paging.total, 2);
+}
+
+export const FLOWS = {
+  "orgs-network": async () => { await organizations(); await acls(); await network(); await feed(); },
+  "orgs-connection": orgsConnection,
+};

package/test/flows/posts.mjs

@@ -0,0 +1,196 @@
+// Post flows: lifecycle, validation, paging, legacy ugcPosts and visibility.
+import assert from "node:assert/strict";
+import { call, del, enc, get, op, orgUrn, partial, personUrn, post, textPost } from "../client.mjs";
+import { ORGS, PEOPLE, POSTS } from "../fixtures.mjs";
+
+const maya = personUrn(PEOPLE.maya);
+const posts = (query) => `/rest/posts?q=author&${query}`;
+
+async function createChecks() {
+  const created = await post("/rest/posts", textPost(maya, "Launching #DataOps week with the team"));
+  const urn = created.headers.get("x-restli-id");
+  assert.match(urn, /^urn:li:share:[0-9]{19}$/);
+  assert.equal(created.headers.get("x-linkedin-id"), urn);
+  const read = (await get(`/rest/posts/${enc(urn)}`)).body;
+  assert.equal(read.commentary, "Launching {hashtag|\\#|DataOps} week with the team");
+  assert.equal(read.author, maya);
+  assert.equal(read.lifecycleState, "PUBLISHED");
+  assert.equal(read.publishedAt, read.createdAt);
+  assert.equal(BigInt(urn.split(":").pop()) >> 22n, BigInt(read.createdAt), "id carries the creation time");
+  const article = await post("/rest/posts", textPost(maya, "Worth a read", {
+    content: { article: { source: "https://example.com/articles/lineage", title: "Lineage at scale", description: "Notes" } } }));
+  const reshare = await post("/rest/posts", textPost(maya, "", { reshareContext: { parent: POSTS.sam.urn } }));
+  const reshared = (await get(`/rest/posts/${enc(reshare.headers.get("x-restli-id"))}`)).body;
+  assert.deepEqual(reshared.reshareContext, { parent: POSTS.sam.urn, root: POSTS.sam.urn });
+  await post("/rest/posts", textPost(orgUrn(ORGS.northwind), "From the Northwind page"));
+  const bad = (body, expect) => post("/rest/posts", body, expect);
+  await bad(textPost(maya, "x", { reshareContext: { parent: POSTS.brightline.urn } }), [422, "UNPROCESSABLE_ENTITY"]);
+  await bad(textPost(maya, "x", { reshareContext: { parent: POSTS.mayaDraft.urn } }), [422, "UNPROCESSABLE_ENTITY"]);
+  await bad(textPost(maya, "x", { reshareContext: { parent: "urn:li:share:12345" } }), [404, "NOT_FOUND"]);
+  await bad(textPost(maya, "x", { reshareContext: {} }), [400, "MISSING_FIELD"]);
+  await bad(textPost(orgUrn(ORGS.brightline), "requested role only"), [403, "ACCESS_DENIED"]);
+  await bad(textPost(orgUrn(ORGS.lakeview), "analyst role only"), [403, "ACCESS_DENIED"]);
+  await bad(textPost(personUrn(PEOPLE.sam), "not me"), [403, "ACCESS_DENIED"]);
+  await bad(textPost(orgUrn(ORGS.northwind), "x", { visibility: "CONNECTIONS" }), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(textPost(maya, "x", { visibility: "FRIENDS" }), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(textPost(maya, "x", { lifecycleState: "DRAFT" }), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(textPost(maya, "x", { distribution: { feedDistribution: "MAIN_FEED", targetEntities: [{ geoLocations: [] }] } }), 400);
+  await bad(textPost(maya, "x", { distribution: { feedDistribution: "MAIN_FEED", thirdPartyDistributionChannels: ["X"] } }),
+    [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(textPost(maya, "x", { content: { media: { category: "IMAGE" } } }), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(textPost(maya, "x", { content: { article: { source: "http://example.com", title: "t" } } }), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await bad(textPost(maya, "x", { content: { article: { source: "https://example.com", title: "  " } } }), [400, "INVALID_VALUE_BLANK_FIELD"]);
+  await bad(textPost(maya, "x", { content: { article: { source: "https://example.com", title: "t".repeat(401) } } }), [400, "FIELD_LENGTH_TOO_LONG"]);
+  await bad(textPost(maya, "x".repeat(3001)), [400, "FIELD_LENGTH_TOO_LONG"]);
+  await bad(textPost(maya, `${"a".repeat(2990)} #tag`), [400, "FIELD_LENGTH_TOO_LONG"]);
+  await bad(textPost(maya, "   "), [400, "INVALID_VALUE_BLANK_FIELD"]);
+  for (const field of ["author", "visibility", "distribution", "lifecycleState"]) {
+    const body = textPost(maya, "x");
+    delete body[field];
+    await bad(body, [400, "MISSING_FIELD"]);
+  }
+  await bad(textPost(maya, "x", { distribution: {} }), [400, "MISSING_FIELD"]);
+  await bad(textPost("urn:li:share:1", "x"), [400, "INVALID_URN_TYPE"]);
+  await bad(textPost("urn:li:person:short", "x"), [400, "INVALID_URN_ID"]);
+  await bad({ ...textPost(maya, "x"), adContext: {} }, [400, "BAD_REQUEST"]);
+  return { urn, article: article.headers.get("x-restli-id") };
+}
+
+async function findChecks() {
+  const all = [];
+  for (const sort of ["LAST_MODIFIED", "CREATED"]) {
+    const first = (await get(posts(`author=${enc(maya)}&sortBy=${sort}&count=10`))).body;
+    assert.equal(first.paging.total, 14);
+    assert.equal(first.elements.length, 10);
+    assert.deepEqual(first.paging.links.map((l) => l.rel), ["next"]);
+    const second = (await get(posts(`author=${enc(maya)}&sortBy=${sort}&count=10&start=10`))).body;
+    assert.equal(second.elements.length, 4);
+    assert.deepEqual(second.paging.links.map((l) => l.rel), ["prev"]);
+    const list = [...first.elements, ...second.elements];
+    assert.equal(new Set(list.map((p) => p.id)).size, 14);
+    const key = sort === "CREATED" ? "createdAt" : "lastModifiedAt";
+    for (let i = 1; i < list.length; i += 1) assert.ok(list[i - 1][key] >= list[i][key], `${sort} order`);
+    assert.ok(!list.some((p) => p.id === POSTS.mayaDraft.urn || p.id === POSTS.mayaDeleted.urn));
+    all.push(list.findIndex((p) => p.id === POSTS.mayaEdited.urn));
+  }
+  assert.notEqual(all[0], all[1], "LAST_MODIFIED and CREATED orders differ");
+  const author = (await get(posts(`author=${enc(maya)}&viewContext=AUTHOR&count=100`))).body;
+  assert.equal(author.paging.total, 15);
+  assert.ok(author.elements.some((p) => p.id === POSTS.mayaDraft.urn && p.publishedAt === undefined));
+  assert.equal((await get(posts(`author=${enc(orgUrn(ORGS.northwind))}`))).body.paging.total, 3);
+  assert.equal((await get(posts(`author=${enc(orgUrn(ORGS.lakeview))}`))).body.paging.total, 0);
+  await get(posts(`author=${enc(orgUrn(ORGS.brightline))}`), [403, "ACCESS_DENIED"]);
+  await get(posts(`author=${enc(orgUrn(99999999))}`), [404, "NOT_FOUND"]);
+  await get(posts(`author=${enc(personUrn(PEOPLE.sam))}`), [403, "ACCESS_DENIED"]);
+  await get("/rest/posts?q=author", [400, "MISSING_FIELD"]);
+  await get(posts(`author=${enc(POSTS.sam.urn)}`), [400, "INVALID_URN_TYPE"]);
+  await get(posts("author=urn%3Ali%3Aperson%3Ax"), [400, "INVALID_URN_ID"]);
+  await get(posts(`author=${enc(maya)}&count=0`), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(posts(`author=${enc(maya)}&sortBy=RELEVANCE`), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(posts(`author=${enc(maya)}&count=abc`), [400, "BAD_REQUEST"]);
+  await get(`/rest/posts?q=dscAdAccount&author=${enc(maya)}`, [400, "BAD_REQUEST"]);
+}
+
+const path = (urn) => `/rest/posts/${enc(urn)}`;
+
+async function readUpdateDelete(created) {
+  await get(path(POSTS.mayaDraft.urn), [404, "NOT_FOUND"]);
+  assert.equal((await get(`${path(POSTS.mayaDraft.urn)}?viewContext=AUTHOR`)).body.lifecycleState, "DRAFT");
+  await get(`${path(POSTS.mayaDraft.urn)}?viewContext=OWNER`, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(path(POSTS.jordan.urn), [403, "ACCESS_DENIED"]);
+  await get(path(POSTS.mayaDeleted.urn), [404, "NOT_FOUND"]);
+  await get(path("urn:li:share:abc"), [400, "BAD_REQUEST"]);
+  assert.equal((await get(path(POSTS.mayaLong.urn))).body.commentary.length, 3000);
+  await op("posts.get", { postUrn: maya }, "INVALID_URN_TYPE");
+  await op("posts.get", { postUrn: "urn:li:share:" }, "INVALID_URN_ID");
+
+  await partial(path(created.urn), { patch: { $set: { commentary: "Edited #DataOps" } } });
+  const edited = (await get(path(created.urn))).body;
+  assert.equal(edited.commentary, "Edited {hashtag|\\#|DataOps}");
+  assert.equal(edited.lifecycleStateInfo.isEditedByAuthor, true);
+  await partial(path(POSTS.mayaDraft.urn), { patch: { $set: { lifecycleState: "PUBLISHED" } } });
+  const published = (await get(path(POSTS.mayaDraft.urn))).body;
+  assert.equal(published.lifecycleState, "PUBLISHED");
+  assert.equal(typeof published.publishedAt, "number");
+  assert.equal(published.lifecycleStateInfo.isEditedByAuthor, false);
+  await partial(path(created.urn), { patch: { $set: { lifecycleState: "DRAFT" } } }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await partial(path(created.urn), { patch: { $set: { foo: 1 } } }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await partial(path(created.urn), { patch: { $delete: ["commentary"] } }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await partial(path(created.urn), { patch: { $set: { contentCallToActionLabel: "LEARN_MORE" } } }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await partial(path(created.urn), { patch: { $set: {} } }, [400, "MISSING_FIELD"]);
+  await partial(path(created.urn), { patch: { $set: { commentary: "y".repeat(3001) } } }, [400, "FIELD_LENGTH_TOO_LONG"]);
+  await partial(path(created.urn), { patch: { $set: { commentary: " " } } }, [400, "INVALID_VALUE_BLANK_FIELD"]);
+  await call("POST", path(created.urn), [400, "BAD_REQUEST"], { json: { patch: { $set: { commentary: "no method header" } } } });
+  await partial(path(POSTS.sam.urn), { patch: { $set: { commentary: "not mine" } } }, [403, "ACCESS_DENIED"]);
+  await partial(path(POSTS.mayaDeleted.urn), { patch: { $set: { commentary: "gone" } } }, [404, "NOT_FOUND"]);
+  await op("posts.update", { postUrn: "urn:li:comment:1", commentary: "x" }, "INVALID_URN_TYPE");
+  await op("posts.update", { postUrn: "urn:li:ugcPost:x", commentary: "x" }, "INVALID_URN_ID");
+
+  await del(path(created.article));
+  await del(path(POSTS.mayaArticle.urn));
+  await del(path(POSTS.mayaArticle.urn));
+  await get(path(POSTS.mayaArticle.urn), [404, "NOT_FOUND"]);
+  await op("comments.list", { target: POSTS.mayaArticle.urn }, "NOT_FOUND");
+  await del(path("urn:li:share:12345"), [404, "NOT_FOUND"]);
+  await del(path(POSTS.sam.urn), [403, "ACCESS_DENIED"]);
+  await op("posts.delete", { postUrn: maya }, "INVALID_URN_TYPE");
+  await op("posts.delete", { postUrn: "urn:li:share:1x" }, "INVALID_URN_ID");
+}
+
+async function lifecycle() {
+  const created = await createChecks();
+  await findChecks();
+  await readUpdateDelete(created);
+}
+
+const ugcBody = (extra = {}) => ({
+  author: maya, lifecycleState: "PUBLISHED", visibility: { "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC" },
+  specificContent: { "com.linkedin.ugc.ShareContent": { shareCommentary: { text: "Hello from the legacy API" }, shareMediaCategory: "NONE", ...extra } },
+});
+
+async function ugcLegacy() {
+  const text = await post("/v2/ugcPosts", ugcBody());
+  assert.match(text.body.id, /^urn:li:ugcPost:[0-9]{19}$/);
+  assert.equal(text.headers.get("x-restli-id"), text.body.id);
+  const read = (await get(path(text.body.id))).body;
+  assert.equal(read.commentary, "Hello from the legacy API");
+  assert.equal(read.visibility, "PUBLIC");
+  const article = await post("/v2/ugcPosts", ugcBody({ shareMediaCategory: "ARTICLE",
+    media: [{ status: "READY", originalUrl: "https://example.com/legacy", title: { text: "Legacy article" }, description: { text: "Shared" } }] }));
+  assert.deepEqual((await get(path(article.body.id))).body.content,
+    { article: { source: "https://example.com/legacy", title: "Legacy article", description: "Shared" } });
+  await post("/v2/ugcPosts", ugcBody({ shareMediaCategory: "IMAGE" }), 400);
+  const { author, ...noAuthor } = ugcBody();
+  void author;
+  await post("/v2/ugcPosts", noAuthor, 400);
+  await del(`/v2/ugcPosts/${enc(text.body.id)}`);
+  await del(`/v2/ugcPosts/${enc(text.body.id)}`);
+  await get(path(text.body.id), [404, "NOT_FOUND"]);
+  await del(`/v2/ugcPosts/${enc("urn:li:ugcPost:12345")}`, 404);
+}
+
+async function visibilityStranger() {
+  await get(path(POSTS.mayaConnections.urn), [403, "ACCESS_DENIED"]);
+  await get(`/rest/socialActions/${enc(POSTS.mayaConnections.urn)}/comments`, [403, "ACCESS_DENIED"]);
+  await get(`/rest/reactions/${enc(`(entity:${POSTS.mayaConnections.activity})`)}?q=entity`, [403, "ACCESS_DENIED"]);
+  await get(`/rest/socialMetadata/${enc(POSTS.mayaConnections.urn)}`, [403, "ACCESS_DENIED"]);
+  assert.equal((await get(path(POSTS.mayaPlain.urn))).body.visibility, "PUBLIC");
+  assert.equal((await get(path(POSTS.mayaLoggedIn.urn))).body.visibility, "LOGGED_IN");
+  const info = (await get("/v2/userinfo")).body;
+  assert.equal(info.email, undefined);
+  assert.equal(info.picture, undefined);
+  assert.equal(info.locale, "es-ES");
+  assert.equal((await get(`/v2/connections/${enc(personUrn(PEOPLE.tomas))}`)).body.firstDegreeSize, 0);
+}
+
+async function visibilityConnection() {
+  assert.equal((await get(path(POSTS.mayaConnections.urn))).body.visibility, "CONNECTIONS");
+  await partial(path(POSTS.mayaConnections.urn), { patch: { $set: { commentary: "hijack" } } }, [403, "ACCESS_DENIED"]);
+  await del(path(POSTS.mayaConnections.urn), [403, "ACCESS_DENIED"]);
+  await get(posts(`author=${enc(maya)}`), [403, "ACCESS_DENIED"]);
+  await get(path(POSTS.mayaDraft.urn), [404, "NOT_FOUND"]);
+}
+
+export const FLOWS = {
+  "posts-lifecycle": lifecycle, "ugc-legacy": ugcLegacy, "visibility-stranger": visibilityStranger, "visibility-connection": visibilityConnection,
+};

package/test/flows/reactions.mjs

@@ -0,0 +1,101 @@
+// Reaction and social metadata flows.
+import assert from "node:assert/strict";
+import { del, enc, get, op, orgUrn, personUrn, post } from "../client.mjs";
+import { COMMENTS, ORGS, PEOPLE, POSTS } from "../fixtures.mjs";
+
+const maya = personUrn(PEOPLE.maya);
+const plain = POSTS.mayaPlain;
+const art = POSTS.mayaArticle;
+const react = (actor, body, expect = 201) => post(`/rest/reactions?actor=${enc(actor)}`, body, expect);
+const key = (actor, entity) => `/rest/reactions/${enc(`(actor:${actor},entity:${entity})`)}`;
+const finder = (entity, query = "") => `/rest/reactions/${enc(`(entity:${entity})`)}?q=entity${query}`;
+const meta = (entity) => `/rest/socialMetadata/${enc(entity)}`;
+
+async function reactions() {
+  const first = (await react(maya, { root: plain.urn, reactionType: "LIKE" })).body;
+  assert.equal(first.id, `urn:li:reaction:(${maya},${plain.activity})`);
+  assert.equal(first.root, plain.activity);
+  for (const type of ["PRAISE", "APPRECIATION", "EMPATHY", "INTEREST", "ENTERTAINMENT"]) {
+    assert.equal((await react(maya, { root: plain.urn, reactionType: type })).body.reactionType, type);
+  }
+  const replay = (await react(maya, { root: plain.urn, reactionType: "ENTERTAINMENT" })).body;
+  assert.equal(replay.created.time, first.created.time);
+  await react(maya, { root: plain.urn, reactionType: "MAYBE" }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await react(maya, { root: plain.urn, reactionType: "LOVE" }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await post("/rest/reactions", { root: plain.urn, reactionType: "LIKE" }, [400, "MISSING_FIELD"]);
+  await react(maya, { reactionType: "LIKE" }, [400, "MISSING_FIELD"]);
+  await react(maya, { root: plain.urn }, [400, "MISSING_FIELD"]);
+  assert.equal((await react(maya, { root: COMMENTS.priyaOnArticle.urn, reactionType: "APPRECIATION" })).body.root, COMMENTS.priyaOnArticle.urn);
+  const asPage = (await react(orgUrn(ORGS.northwind), { root: POSTS.northwindArticle.urn, reactionType: "LIKE" })).body;
+  assert.equal(asPage.created.impersonator, maya);
+  await react(orgUrn(ORGS.brightline), { root: plain.urn, reactionType: "LIKE" }, [403, "ACCESS_DENIED"]);
+  await react(personUrn(PEOPLE.sam), { root: plain.urn, reactionType: "LIKE" }, [403, "ACCESS_DENIED"]);
+  await react(maya, { root: "urn:li:share:12345", reactionType: "LIKE" }, [404, "NOT_FOUND"]);
+  await react(maya, { root: POSTS.mayaDraft.urn, reactionType: "LIKE" }, [404, "NOT_FOUND"]);
+  await react(maya, { root: POSTS.jordan.urn, reactionType: "LIKE" }, [403, "ACCESS_DENIED"]);
+  await op("reactions.create", { actor: "urn:li:share:1", root: plain.urn, reactionType: "LIKE" }, "INVALID_URN_TYPE");
+  await op("reactions.create", { actor: maya, root: "urn:li:share:x", reactionType: "LIKE" }, "INVALID_URN_ID");
+
+  const single = (await get(key(maya, plain.activity))).body;
+  assert.equal(single.reactionType, "ENTERTAINMENT");
+  assert.equal(single.paging, undefined);
+  await get(key(personUrn(PEOPLE.sam), plain.activity), [404, "NOT_FOUND"]);
+  await get(`/rest/reactions/${enc(`(entity:${art.activity})`)}`, [400, "BAD_REQUEST"]);
+  const newest = (await get(finder(art.activity, "&count=2"))).body;
+  assert.equal(newest.paging.total, 6);
+  assert.deepEqual(newest.elements.map((r) => r.reactionType), ["ENTERTAINMENT", "INTEREST"]);
+  assert.equal(newest.paging.links[0].rel, "next");
+  const oldest = (await get(finder(art.activity, `&sort=${enc("(value:CHRONOLOGICAL)")}&count=2&start=4`))).body;
+  assert.deepEqual(oldest.elements.map((r) => r.reactionType), ["INTEREST", "ENTERTAINMENT"]);
+  assert.equal((await get(finder(art.activity, `&sort=${enc("(value:RELEVANCE)")}`))).body.elements.length, 6);
+  await get(finder(art.activity, `&sort=${enc("(value:FOO)")}`), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(finder(art.activity, "&count=0"), [400, "INVALID_VALUE_FOR_FIELD"]);
+  await get(finder("urn:li:activity:12345"), [404, "NOT_FOUND"]);
+  await get(finder(POSTS.jordan.activity), [403, "ACCESS_DENIED"]);
+  await op("reactions.list", { entity: art.activity, single: true }, "MISSING_FIELD");
+  await op("reactions.list", { entity: maya }, "INVALID_URN_TYPE");
+  await op("reactions.list", { entity: "urn:li:activity:" }, "INVALID_URN_ID");
+
+  await del(key(maya, plain.activity));
+  await del(key(maya, plain.activity), [404, "NOT_FOUND"]);
+  await del(key(personUrn(PEOPLE.sam), art.activity), [403, "ACCESS_DENIED"]);
+  await del(`/rest/reactions/${enc("(actor:x)")}`, [400, "BAD_REQUEST"]);
+  await op("reactions.delete", { actor: "urn:li:share:1", entity: plain.activity }, "INVALID_URN_TYPE");
+  await op("reactions.delete", { actor: maya, entity: "urn:li:activity:" }, "INVALID_URN_ID");
+}
+
+async function metadata() {
+  const post1 = (await get(meta(art.urn))).body;
+  assert.deepEqual(post1.commentSummary, { count: 5, topLevelCount: 3 });
+  assert.equal(post1.commentsState, "OPEN");
+  assert.deepEqual(Object.keys(post1.reactionSummaries), ["LIKE", "PRAISE", "APPRECIATION", "EMPATHY", "INTEREST", "ENTERTAINMENT"]);
+  const onComment = (await get(meta(COMMENTS.samOnArticle.urn))).body;
+  assert.deepEqual(onComment.commentSummary, { count: 1, topLevelCount: 1 });
+  assert.deepEqual(onComment.reactionSummaries, { LIKE: { reactionType: "LIKE", count: 1 } });
+  await get(meta("urn:li:share:12345"), [404, "NOT_FOUND"]);
+  await get(meta(POSTS.jordan.urn), [403, "ACCESS_DENIED"]);
+  await get(meta("urn:li:share:x"), [400, "BAD_REQUEST"]);
+  await op("social_metadata.get", { entity: maya }, "INVALID_URN_TYPE");
+  await op("social_metadata.get", { entity: "urn:li:share:" }, "INVALID_URN_ID");
+
+  const set = (entity, actor, state, expect = 202) => post(`${meta(entity)}?actor=${enc(actor)}`, { patch: { $set: { commentsState: state } } }, expect);
+  await set(art.urn, maya, "CLOSED");
+  const closed = (await get(meta(art.urn))).body;
+  assert.equal(closed.commentsState, "CLOSED");
+  assert.deepEqual(closed.commentSummary, { count: 0, topLevelCount: 0 });
+  assert.equal(Object.keys(closed.reactionSummaries).length, 6);
+  const closedAgain = await op("social_metadata.set_comments_state", { entity: art.urn, actor: maya, commentsState: "CLOSED" });
+  assert.equal(closedAgain.value.deletedComments, 0);
+  await set(art.urn, maya, "OPEN");
+  assert.equal((await get(meta(art.urn))).body.commentsState, "OPEN");
+  await set(COMMENTS.zoeOnArticle.urn, maya, "CLOSED", [400, "BAD_REQUEST"]);
+  await op("social_metadata.set_comments_state", { entity: COMMENTS.zoeOnArticle.urn, actor: maya, commentsState: "CLOSED" }, "INVALID_URN_TYPE");
+  await op("social_metadata.set_comments_state", { entity: "urn:li:activity:", actor: maya, commentsState: "CLOSED" }, "INVALID_URN_ID");
+  await set(art.urn, maya, "PROCESSING", [400, "INVALID_VALUE_FOR_FIELD"]);
+  await post(meta(art.urn), { patch: { $set: { foo: "bar" } } }, [400, "INVALID_VALUE_FOR_FIELD"]);
+  await set(art.urn, orgUrn(ORGS.northwind), "CLOSED", [403, "ACCESS_DENIED"]);
+  await post(meta(art.urn), { patch: { $set: { commentsState: "CLOSED" } } }, [400, "MISSING_FIELD"]);
+  await set("urn:li:share:12345", maya, "CLOSED", [404, "NOT_FOUND"]);
+}
+
+export const FLOWS = { "reactions-metadata": async () => { await reactions(); await metadata(); } };

package/test/flows/wire.mjs

@@ -0,0 +1,62 @@
+// Wire-level errors: LinkedIn-Version, X-RestLi-Method, batch get, malformed bodies and query strings, on every /rest route.
+import assert from "node:assert/strict";
+import { call, enc, get, op, orgUrn, personUrn, post, textPost } from "../client.mjs";
+import { COMMENTS, ORGS, PEOPLE, POSTS } from "../fixtures.mjs";
+
+const maya = personUrn(PEOPLE.maya);
+const social = (target) => `/rest/socialActions/${enc(target)}/comments`;
+
+// [label, method, path, body, Rest.li method]
+const ROUTES = [
+  ["create-post", "POST", "/rest/posts", textPost(maya, "never stored"), "CREATE"],
+  ["get-post", "GET", `/rest/posts/${enc(POSTS.mayaPlain.urn)}`, undefined, "GET"],
+  ["find-posts", "GET", `/rest/posts?q=author&author=${enc(maya)}`, undefined, "FINDER"],
+  ["update-post", "POST", `/rest/posts/${enc(POSTS.mayaPlain.urn)}`, { patch: { $set: { commentary: "never" } } }, "PARTIAL_UPDATE"],
+  ["delete-post", "DELETE", `/rest/posts/${enc(POSTS.mayaPlain.urn)}`, undefined, "DELETE"],
+  ["create-comment", "POST", social(POSTS.mayaPlain.urn), { actor: maya, message: { text: "never" } }, "CREATE"],
+  ["list-comments", "GET", social(POSTS.mayaArticle.urn), undefined, "GET_ALL"],
+  ["get-comment", "GET", `${social(POSTS.mayaArticle.urn)}/${COMMENTS.samOnArticle.id}`, undefined, "GET"],
+  ["update-comment", "POST", `${social(POSTS.zoe.urn)}/${COMMENTS.mayaOnZoe.id}`, { patch: { message: { $set: { text: "never" } } } }, "PARTIAL_UPDATE"],
+  ["delete-comment", "DELETE", `${social(POSTS.zoe.urn)}/${COMMENTS.mayaOnZoe.id}`, undefined, "DELETE"],
+  ["create-reaction", "POST", `/rest/reactions?actor=${enc(maya)}`, { root: POSTS.mayaPlain.urn, reactionType: "LIKE" }, "CREATE"],
+  ["get-reactions", "GET", `/rest/reactions/${enc(`(entity:${POSTS.mayaArticle.activity})`)}?q=entity`, undefined, "FINDER"],
+  ["delete-reaction", "DELETE", `/rest/reactions/${enc(`(actor:${maya},entity:${POSTS.zoe.activity})`)}`, undefined, "DELETE"],
+  ["get-social-metadata", "GET", `/rest/socialMetadata/${enc(POSTS.mayaArticle.urn)}`, undefined, "GET"],
+  ["update-social-metadata", "POST", `/rest/socialMetadata/${enc(POSTS.mayaPlain.urn)}?actor=${enc(maya)}`,
+    { patch: { $set: { commentsState: "CLOSED" } } }, "PARTIAL_UPDATE"],
+  ["get-organization", "GET", `/rest/organizations/${ORGS.northwind}`, undefined, "GET"],
+  ["find-organizations", "GET", "/rest/organizations?q=vanityName&vanityName=northwind-analytics", undefined, "FINDER"],
+  ["find-organization-acls", "GET", "/rest/organizationAcls?q=roleAssignee", undefined, "FINDER"],
+  ["get-network-size", "GET", `/rest/networkSizes/${enc(orgUrn(ORGS.northwind))}?edgeType=COMPANY_FOLLOWED_BY_MEMBER`, undefined, "GET"],
+];
+
+async function wireErrors() {
+  for (const [label, method, path, json, restli] of ROUTES) {
+    const options = (extra) => ({ json, restli, ...extra });
+    const missing = (await call(method, path, [400, "VERSION_MISSING"], options({ version: null }))).body;
+    assert.match(missing.message, /Linkedin-Version header/, label);
+    const inactive = (await call(method, path, [426, "NONEXISTENT_VERSION"], options({ version: "202508" }))).body;
+    assert.equal(inactive.message, "Requested version 202508 is not active", label);
+    await call(method, path, [426, "NONEXISTENT_VERSION"], options({ version: "abc" }));
+    await call(method, path, [400, "BAD_REQUEST"], options({ restli: "BATCH_GET" }));
+    await call(method, `${path}${path.includes("?") ? "&" : "?"}ids=List(1,2)`, [400, "BAD_REQUEST"], options({}));
+  }
+  const deep = `{"author":"${maya}","commentary":"x","visibility":"PUBLIC","distribution":{"feedDistribution":"MAIN_FEED"},"lifecycleState":"PUBLISHED",`
+    + `"content":${"[".repeat(600)}${"]".repeat(600)}}`;
+  await post("/rest/posts", deep, [400, "BAD_REQUEST"]);
+  // The framework drops an own `__proto__` member before the codec runs; the request still fails validation and pollutes nothing.
+  await post("/rest/posts", `{"__proto__":{"polluted":1},"author":"${maya}"}`, 400);
+  await post("/rest/posts", "[1,2,3]", [400, "BAD_REQUEST"]);
+  assert.equal({}.polluted, undefined);
+  await get(`/rest/posts?q=author&${Array.from({ length: 21 }, () => `author=${enc(maya)}`).join("&")}`, [400, "BAD_REQUEST"]);
+  await get("/rest/posts?q=author&author=%FF", [400, "BAD_REQUEST"]);
+  await get("/rest/posts?q=author&author=%ZZ", [400, "INVALID_URN_ID"]);
+  await post("/v2/ugcPosts", "[]", 400);
+  await call("DELETE", `/v2/ugcPosts/${enc("urn:li:ugcPost:abc")}`, 400);
+  await get(`/v2/people/${enc("(id:x")}`, 400);
+  await op("feed.list", { count: 0 }, "INVALID_VALUE_FOR_FIELD");
+  await op("connections.list", { count: 0 }, "INVALID_VALUE_FOR_FIELD");
+  assert.equal((await get(`/rest/posts/${enc(POSTS.mayaPlain.urn)}`)).body.commentary.startsWith("Shipping"), true);
+}
+
+export const FLOWS = { "wire-errors": wireErrors };