1 jest.setTimeout(120000);
3 import { CommunityView } from "lemmy-js-client/dist/types/CommunityView";
28 banPersonFromCommunity,
38 import { PostView } from "lemmy-js-client/dist/types/PostView";
40 let betaCommunity: CommunityView | undefined;
42 beforeAll(async () => {
44 betaCommunity = (await resolveBetaCommunity(alpha)).community;
45 expect(betaCommunity).toBeDefined();
49 afterAll(async () => {
53 function assertPostFederation(postOne?: PostView, postTwo?: PostView) {
54 expect(postOne?.post.ap_id).toBe(postTwo?.post.ap_id);
55 expect(postOne?.post.name).toBe(postTwo?.post.name);
56 expect(postOne?.post.body).toBe(postTwo?.post.body);
57 // TODO url clears arent working
58 // expect(postOne?.post.url).toBe(postTwo?.post.url);
59 expect(postOne?.post.nsfw).toBe(postTwo?.post.nsfw);
60 expect(postOne?.post.embed_title).toBe(postTwo?.post.embed_title);
61 expect(postOne?.post.embed_description).toBe(postTwo?.post.embed_description);
62 expect(postOne?.post.embed_video_url).toBe(postTwo?.post.embed_video_url);
63 expect(postOne?.post.published).toBe(postTwo?.post.published);
64 expect(postOne?.community.actor_id).toBe(postTwo?.community.actor_id);
65 expect(postOne?.post.locked).toBe(postTwo?.post.locked);
66 expect(postOne?.post.removed).toBe(postTwo?.post.removed);
67 expect(postOne?.post.deleted).toBe(postTwo?.post.deleted);
70 test("Create a post", async () => {
72 throw "Missing beta community";
75 let postRes = await createPost(alpha, betaCommunity.community.id);
76 expect(postRes.post_view.post).toBeDefined();
77 expect(postRes.post_view.community.local).toBe(false);
78 expect(postRes.post_view.creator.local).toBe(true);
79 expect(postRes.post_view.counts.score).toBe(1);
81 // Make sure that post is liked on beta
82 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
84 expect(betaPost).toBeDefined();
85 expect(betaPost?.community.local).toBe(true);
86 expect(betaPost?.creator.local).toBe(false);
87 expect(betaPost?.counts.score).toBe(1);
88 assertPostFederation(betaPost, postRes.post_view);
90 // Delta only follows beta, so it should not see an alpha ap_id
91 let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
92 expect(deltaPost).toBeUndefined();
94 // Epsilon has alpha blocked, it should not see the alpha post
95 let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
96 expect(epsilonPost).toBeUndefined();
99 test("Create a post in a non-existent community", async () => {
100 let postRes = (await createPost(alpha, -2)) as any;
101 expect(postRes.error).toBe("couldnt_find_community");
104 test("Unlike a post", async () => {
105 if (!betaCommunity) {
106 throw "Missing beta community";
108 let postRes = await createPost(alpha, betaCommunity.community.id);
109 let unlike = await likePost(alpha, 0, postRes.post_view.post);
110 expect(unlike.post_view.counts.score).toBe(0);
112 // Try to unlike it again, make sure it stays at 0
113 let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
114 expect(unlike2.post_view.counts.score).toBe(0);
116 // Make sure that post is unliked on beta
117 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
118 expect(betaPost).toBeDefined();
119 expect(betaPost?.community.local).toBe(true);
120 expect(betaPost?.creator.local).toBe(false);
121 expect(betaPost?.counts.score).toBe(0);
122 assertPostFederation(betaPost, postRes.post_view);
125 test("Update a post", async () => {
126 if (!betaCommunity) {
127 throw "Missing beta community";
129 let postRes = await createPost(alpha, betaCommunity.community.id);
131 let updatedName = "A jest test federated post, updated";
132 let updatedPost = await editPost(alpha, postRes.post_view.post);
133 expect(updatedPost.post_view.post.name).toBe(updatedName);
134 expect(updatedPost.post_view.community.local).toBe(false);
135 expect(updatedPost.post_view.creator.local).toBe(true);
137 // Make sure that post is updated on beta
138 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
140 throw "Missing beta post";
142 expect(betaPost.community.local).toBe(true);
143 expect(betaPost.creator.local).toBe(false);
144 expect(betaPost.post.name).toBe(updatedName);
145 assertPostFederation(betaPost, updatedPost.post_view);
147 // Make sure lemmy beta cannot update the post
148 let updatedPostBeta = (await editPost(beta, betaPost.post)) as any;
149 expect(updatedPostBeta.error).toBe("no_post_edit_allowed");
152 test("Sticky a post", async () => {
153 if (!betaCommunity) {
154 throw "Missing beta community";
156 let postRes = await createPost(alpha, betaCommunity.community.id);
158 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
160 throw "Missing beta post1";
162 let stickiedPostRes = await featurePost(beta, true, betaPost1.post);
163 expect(stickiedPostRes.post_view.post.featured_community).toBe(true);
165 // Make sure that post is stickied on beta
166 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
167 expect(betaPost?.community.local).toBe(true);
168 expect(betaPost?.creator.local).toBe(false);
169 expect(betaPost?.post.featured_community).toBe(true);
172 let unstickiedPost = await featurePost(beta, false, betaPost1.post);
173 expect(unstickiedPost.post_view.post.featured_community).toBe(false);
175 // Make sure that post is unstickied on beta
176 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
177 expect(betaPost2?.community.local).toBe(true);
178 expect(betaPost2?.creator.local).toBe(false);
179 expect(betaPost2?.post.featured_community).toBe(false);
181 // Make sure that gamma cannot sticky the post on beta
182 let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
184 throw "Missing gamma post";
186 let gammaTrySticky = await featurePost(gamma, true, gammaPost.post);
187 let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post;
188 expect(gammaTrySticky.post_view.post.featured_community).toBe(true);
189 expect(betaPost3?.post.featured_community).toBe(false);
192 test("Lock a post", async () => {
193 if (!betaCommunity) {
194 throw "Missing beta community";
196 await followCommunity(alpha, true, betaCommunity.community.id);
197 let postRes = await createPost(alpha, betaCommunity.community.id);
200 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
202 throw "Missing beta post1";
204 let lockedPostRes = await lockPost(beta, true, betaPost1.post);
205 expect(lockedPostRes.post_view.post.locked).toBe(true);
207 // Make sure that post is locked on alpha
208 let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
209 let alphaPost1 = searchAlpha.posts[0];
210 expect(alphaPost1.post.locked).toBe(true);
212 // Try to make a new comment there, on alpha
213 let comment: any = await createComment(alpha, alphaPost1.post.id);
214 expect(comment["error"]).toBe("locked");
217 let unlockedPost = await lockPost(beta, false, betaPost1.post);
218 expect(unlockedPost.post_view.post.locked).toBe(false);
220 // Make sure that post is unlocked on alpha
221 let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
222 let alphaPost2 = searchAlpha2.posts[0];
223 expect(alphaPost2.community.local).toBe(false);
224 expect(alphaPost2.creator.local).toBe(true);
225 expect(alphaPost2.post.locked).toBe(false);
227 // Try to create a new comment, on alpha
228 let commentAlpha = await createComment(alpha, alphaPost1.post.id);
229 expect(commentAlpha).toBeDefined();
232 test("Delete a post", async () => {
233 if (!betaCommunity) {
234 throw "Missing beta community";
237 let postRes = await createPost(alpha, betaCommunity.community.id);
238 expect(postRes.post_view.post).toBeDefined();
240 let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
241 expect(deletedPost.post_view.post.deleted).toBe(true);
242 expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
244 // Make sure lemmy beta sees post is deleted
245 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
246 // This will be undefined because of the tombstone
247 expect(betaPost).toBeUndefined();
250 let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
251 expect(undeletedPost.post_view.post.deleted).toBe(false);
253 // Make sure lemmy beta sees post is undeleted
254 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
256 throw "Missing beta post 2";
258 expect(betaPost2.post.deleted).toBe(false);
259 assertPostFederation(betaPost2, undeletedPost.post_view);
261 // Make sure lemmy beta cannot delete the post
262 let deletedPostBeta = (await deletePost(beta, true, betaPost2.post)) as any;
263 expect(deletedPostBeta.error).toStrictEqual("no_post_edit_allowed");
266 test("Remove a post from admin and community on different instance", async () => {
267 if (!betaCommunity) {
268 throw "Missing beta community";
271 let gammaCommunity = (
272 await resolveCommunity(gamma, betaCommunity.community.actor_id)
273 ).community?.community;
274 if (!gammaCommunity) {
275 throw "Missing gamma community";
277 let postRes = await createPost(gamma, gammaCommunity.id);
279 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
281 throw "Missing alpha post";
283 let removedPost = await removePost(alpha, true, alphaPost.post);
284 expect(removedPost.post_view.post.removed).toBe(true);
285 expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
287 // Make sure lemmy beta sees post is NOT removed
288 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
290 throw "Missing beta post";
292 expect(betaPost.post.removed).toBe(false);
295 let undeletedPost = await removePost(alpha, false, alphaPost.post);
296 expect(undeletedPost.post_view.post.removed).toBe(false);
298 // Make sure lemmy beta sees post is undeleted
299 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
300 expect(betaPost2?.post.removed).toBe(false);
301 assertPostFederation(betaPost2, undeletedPost.post_view);
304 test("Remove a post from admin and community on same instance", async () => {
305 if (!betaCommunity) {
306 throw "Missing beta community";
308 await followBeta(alpha);
309 let postRes = await createPost(alpha, betaCommunity.community.id);
310 expect(postRes.post_view.post).toBeDefined();
312 // Get the id for beta
313 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
314 let betaPost = searchBeta.posts[0];
315 expect(betaPost).toBeDefined();
317 // The beta admin removes it (the community lives on beta)
318 let removePostRes = await removePost(beta, true, betaPost.post);
319 expect(removePostRes.post_view.post.removed).toBe(true);
321 // Make sure lemmy alpha sees post is removed
322 // let alphaPost = await getPost(alpha, postRes.post_view.post.id);
323 // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
324 // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
327 let undeletedPost = await removePost(beta, false, betaPost.post);
328 expect(undeletedPost.post_view.post.removed).toBe(false);
330 // Make sure lemmy alpha sees post is undeleted
331 let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
332 expect(alphaPost2.post_view.post.removed).toBe(false);
333 assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
334 await unfollowRemotes(alpha);
337 test("Search for a post", async () => {
338 if (!betaCommunity) {
339 throw "Missing beta community";
341 await unfollowRemotes(alpha);
342 let postRes = await createPost(alpha, betaCommunity.community.id);
343 expect(postRes.post_view.post).toBeDefined();
345 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
346 expect(betaPost?.post.name).toBeDefined();
349 test("Enforce site ban for federated user", async () => {
350 if (!betaCommunity) {
351 throw "Missing beta community";
353 // create a test user
354 let alphaUserJwt = await registerUser(alpha);
355 expect(alphaUserJwt).toBeDefined();
356 let alpha_user: API = {
357 client: alpha.client,
358 auth: alphaUserJwt.jwt ?? "",
360 let alphaUserActorId = (await getSite(alpha_user)).my_user?.local_user_view
362 if (!alphaUserActorId) {
363 throw "Missing alpha user actor id";
365 expect(alphaUserActorId).toBeDefined();
366 let alphaPerson = (await resolvePerson(alpha_user, alphaUserActorId)).person;
368 throw "Missing alpha person";
370 expect(alphaPerson).toBeDefined();
372 // alpha makes post in beta community, it federates to beta instance
373 let postRes1 = await createPost(alpha_user, betaCommunity.community.id);
374 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
375 expect(searchBeta1.posts[0]).toBeDefined();
377 // ban alpha from its instance
378 let banAlpha = await banPersonFromSite(
380 alphaPerson.person.id,
384 expect(banAlpha.banned).toBe(true);
386 // alpha ban should be federated to beta
387 let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
388 expect(alphaUserOnBeta1.person?.person.banned).toBe(true);
390 // existing alpha post should be removed on beta
391 let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
392 expect(searchBeta2.posts[0].post.removed).toBe(true);
395 let unBanAlpha = await banPersonFromSite(
397 alphaPerson.person.id,
401 expect(unBanAlpha.banned).toBe(false);
403 // alpha makes new post in beta community, it federates
404 let postRes2 = await createPost(alpha_user, betaCommunity.community.id);
405 let searchBeta3 = await searchPostLocal(beta, postRes2.post_view.post);
406 expect(searchBeta3.posts[0]).toBeDefined();
408 let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId);
409 expect(alphaUserOnBeta2.person?.person.banned).toBe(false);
412 test("Enforce community ban for federated user", async () => {
413 if (!betaCommunity) {
414 throw "Missing beta community";
416 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
417 let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
419 throw "Missing alpha person";
421 expect(alphaPerson).toBeDefined();
423 // make a post in beta, it goes through
424 let postRes1 = await createPost(alpha, betaCommunity.community.id);
425 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
426 expect(searchBeta1.posts[0]).toBeDefined();
428 // ban alpha from beta community
429 let banAlpha = await banPersonFromCommunity(
431 alphaPerson.person.id,
436 expect(banAlpha.banned).toBe(true);
438 // ensure that the post by alpha got removed
439 let searchAlpha1 = await searchPostLocal(alpha, postRes1.post_view.post);
440 expect(searchAlpha1.posts[0].post.removed).toBe(true);
442 // Alpha tries to make post on beta, but it fails because of ban
443 let postRes2 = await createPost(alpha, betaCommunity.community.id);
444 expect(postRes2.post_view).toBeUndefined();
447 let unBanAlpha = await banPersonFromCommunity(
449 alphaPerson.person.id,
454 expect(unBanAlpha.banned).toBe(false);
455 let postRes3 = await createPost(alpha, betaCommunity.community.id);
456 expect(postRes3.post_view.post).toBeDefined();
457 expect(postRes3.post_view.community.local).toBe(false);
458 expect(postRes3.post_view.creator.local).toBe(true);
459 expect(postRes3.post_view.counts.score).toBe(1);
461 // Make sure that post makes it to beta community
462 let searchBeta2 = await searchPostLocal(beta, postRes3.post_view.post);
463 expect(searchBeta2.posts[0]).toBeDefined();
466 test("A and G subscribe to B (center) A posts, it gets announced to G", async () => {
467 if (!betaCommunity) {
468 throw "Missing beta community";
470 let postRes = await createPost(alpha, betaCommunity.community.id);
471 expect(postRes.post_view.post).toBeDefined();
473 let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
474 expect(betaPost?.post.name).toBeDefined();
477 test("Report a post", async () => {
478 // Note, this is a different one from the setup
479 let betaCommunity = (await resolveBetaCommunity(beta)).community;
480 if (!betaCommunity) {
481 throw "Missing beta community";
483 let postRes = await createPost(beta, betaCommunity.community.id);
484 expect(postRes.post_view.post).toBeDefined();
486 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
488 throw "Missing alpha post";
491 await reportPost(alpha, alphaPost.post.id, randomString(10))
492 ).post_report_view.post_report;
494 let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
495 expect(betaReport).toBeDefined();
496 expect(betaReport.resolved).toBe(false);
497 expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
498 expect(betaReport.original_post_url).toBe(alphaReport.original_post_url);
499 expect(betaReport.original_post_body).toBe(alphaReport.original_post_body);
500 expect(betaReport.reason).toBe(alphaReport.reason);