1 jest.setTimeout(120000);
26 banPersonFromCommunity,
34 import { PostView, CommunityView } from 'lemmy-js-client';
36 let betaCommunity: CommunityView;
38 beforeAll(async () => {
40 betaCommunity = (await resolveBetaCommunity(alpha)).community;
41 expect(betaCommunity).toBeDefined();
45 afterAll(async () => {
49 async function unfollows() {
50 await unfollowRemotes(alpha);
51 await unfollowRemotes(gamma);
52 await unfollowRemotes(delta);
53 await unfollowRemotes(epsilon);
56 function assertPostFederation(postOne: PostView, postTwo: PostView) {
57 expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
58 expect(postOne.post.name).toBe(postTwo.post.name);
59 expect(postOne.post.body).toBe(postTwo.post.body);
60 expect(postOne.post.url).toBe(postTwo.post.url);
61 expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
62 expect(postOne.post.embed_title).toBe(postTwo.post.embed_title);
63 expect(postOne.post.embed_description).toBe(postTwo.post.embed_description);
64 expect(postOne.post.embed_html).toBe(postTwo.post.embed_html);
65 expect(postOne.post.published).toBe(postTwo.post.published);
66 expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
67 expect(postOne.post.locked).toBe(postTwo.post.locked);
68 expect(postOne.post.removed).toBe(postTwo.post.removed);
69 expect(postOne.post.deleted).toBe(postTwo.post.deleted);
72 test('Create a post', async () => {
73 let postRes = await createPost(alpha, betaCommunity.community.id);
74 expect(postRes.post_view.post).toBeDefined();
75 expect(postRes.post_view.community.local).toBe(false);
76 expect(postRes.post_view.creator.local).toBe(true);
77 expect(postRes.post_view.counts.score).toBe(1);
79 // Make sure that post is liked on beta
80 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
82 expect(betaPost).toBeDefined();
83 expect(betaPost.community.local).toBe(true);
84 expect(betaPost.creator.local).toBe(false);
85 expect(betaPost.counts.score).toBe(1);
86 assertPostFederation(betaPost, postRes.post_view);
88 // Delta only follows beta, so it should not see an alpha ap_id
89 let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
90 expect(deltaPost).toBeUndefined();
92 // Epsilon has alpha blocked, it should not see the alpha post
93 let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
94 expect(epsilonPost).toBeUndefined();
97 test('Create a post in a non-existent community', async () => {
98 let postRes = await createPost(alpha, -2);
99 expect(postRes).toStrictEqual({ error: 'couldnt_find_community' });
102 test('Unlike a post', async () => {
103 let postRes = await createPost(alpha, betaCommunity.community.id);
104 let unlike = await likePost(alpha, 0, postRes.post_view.post);
105 expect(unlike.post_view.counts.score).toBe(0);
107 // Try to unlike it again, make sure it stays at 0
108 let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
109 expect(unlike2.post_view.counts.score).toBe(0);
111 // Make sure that post is unliked on beta
112 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
113 expect(betaPost).toBeDefined();
114 expect(betaPost.community.local).toBe(true);
115 expect(betaPost.creator.local).toBe(false);
116 expect(betaPost.counts.score).toBe(0);
117 assertPostFederation(betaPost, postRes.post_view);
120 test('Update a post', async () => {
121 let postRes = await createPost(alpha, betaCommunity.community.id);
123 let updatedName = 'A jest test federated post, updated';
124 let updatedPost = await editPost(alpha, postRes.post_view.post);
125 expect(updatedPost.post_view.post.name).toBe(updatedName);
126 expect(updatedPost.post_view.community.local).toBe(false);
127 expect(updatedPost.post_view.creator.local).toBe(true);
129 // Make sure that post is updated on beta
130 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
131 expect(betaPost.community.local).toBe(true);
132 expect(betaPost.creator.local).toBe(false);
133 expect(betaPost.post.name).toBe(updatedName);
134 assertPostFederation(betaPost, updatedPost.post_view);
136 // Make sure lemmy beta cannot update the post
137 let updatedPostBeta = await editPost(beta, betaPost.post);
138 expect(updatedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
141 test('Sticky a post', async () => {
142 let postRes = await createPost(alpha, betaCommunity.community.id);
144 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
145 let stickiedPostRes = await stickyPost(beta, true, betaPost1.post);
146 expect(stickiedPostRes.post_view.post.stickied).toBe(true);
148 // Make sure that post is stickied on beta
149 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
150 expect(betaPost.community.local).toBe(true);
151 expect(betaPost.creator.local).toBe(false);
152 expect(betaPost.post.stickied).toBe(true);
155 let unstickiedPost = await stickyPost(beta, false, betaPost1.post);
156 expect(unstickiedPost.post_view.post.stickied).toBe(false);
158 // Make sure that post is unstickied on beta
159 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
160 expect(betaPost2.community.local).toBe(true);
161 expect(betaPost2.creator.local).toBe(false);
162 expect(betaPost2.post.stickied).toBe(false);
164 // Make sure that gamma cannot sticky the post on beta
165 let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
166 let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
167 let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post;
168 expect(gammaTrySticky.post_view.post.stickied).toBe(true);
169 expect(betaPost3.post.stickied).toBe(false);
172 test('Lock a post', async () => {
173 await followCommunity(alpha, true, betaCommunity.community.id);
174 let postRes = await createPost(alpha, betaCommunity.community.id);
177 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
178 let lockedPostRes = await lockPost(beta, true, betaPost1.post);
179 expect(lockedPostRes.post_view.post.locked).toBe(true);
181 // Make sure that post is locked on alpha
182 let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
183 let alphaPost1 = searchAlpha.posts[0];
184 expect(alphaPost1.post.locked).toBe(true);
186 // Try to make a new comment there, on alpha
187 let comment: any = await createComment(alpha, alphaPost1.post.id);
188 expect(comment['error']).toBe('locked');
191 let unlockedPost = await lockPost(beta, false, betaPost1.post);
192 expect(unlockedPost.post_view.post.locked).toBe(false);
194 // Make sure that post is unlocked on alpha
195 let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
196 let alphaPost2 = searchAlpha2.posts[0];
197 expect(alphaPost2.community.local).toBe(false);
198 expect(alphaPost2.creator.local).toBe(true);
199 expect(alphaPost2.post.locked).toBe(false);
201 // Try to create a new comment, on alpha
202 let commentAlpha = await createComment(alpha, alphaPost1.post.id);
203 expect(commentAlpha).toBeDefined();
206 test('Delete a post', async () => {
207 let postRes = await createPost(alpha, betaCommunity.community.id);
208 expect(postRes.post_view.post).toBeDefined();
210 let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
211 expect(deletedPost.post_view.post.deleted).toBe(true);
212 expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
214 // Make sure lemmy beta sees post is deleted
215 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
216 // This will be undefined because of the tombstone
217 expect(betaPost).toBeUndefined();
220 let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
221 expect(undeletedPost.post_view.post.deleted).toBe(false);
223 // Make sure lemmy beta sees post is undeleted
224 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
225 expect(betaPost2.post.deleted).toBe(false);
226 assertPostFederation(betaPost2, undeletedPost.post_view);
228 // Make sure lemmy beta cannot delete the post
229 let deletedPostBeta = await deletePost(beta, true, betaPost2.post);
230 expect(deletedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
233 test('Remove a post from admin and community on different instance', async () => {
234 let postRes = await createPost(alpha, betaCommunity.community.id);
236 let removedPost = await removePost(alpha, true, postRes.post_view.post);
237 expect(removedPost.post_view.post.removed).toBe(true);
238 expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
240 // Make sure lemmy beta sees post is NOT removed
241 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
242 expect(betaPost.post.removed).toBe(false);
245 let undeletedPost = await removePost(alpha, false, postRes.post_view.post);
246 expect(undeletedPost.post_view.post.removed).toBe(false);
248 // Make sure lemmy beta sees post is undeleted
249 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
250 expect(betaPost2.post.removed).toBe(false);
251 assertPostFederation(betaPost2, undeletedPost.post_view);
254 test('Remove a post from admin and community on same instance', async () => {
255 await followBeta(alpha);
256 let postRes = await createPost(alpha, betaCommunity.community.id);
257 expect(postRes.post_view.post).toBeDefined();
259 // Get the id for beta
260 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
261 let betaPost = searchBeta.posts[0];
262 expect(betaPost).toBeDefined();
264 // The beta admin removes it (the community lives on beta)
265 let removePostRes = await removePost(beta, true, betaPost.post);
266 expect(removePostRes.post_view.post.removed).toBe(true);
268 // Make sure lemmy alpha sees post is removed
269 let alphaPost = await getPost(alpha, postRes.post_view.post.id);
270 // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
271 // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
274 let undeletedPost = await removePost(beta, false, betaPost.post);
275 expect(undeletedPost.post_view.post.removed).toBe(false);
277 // Make sure lemmy alpha sees post is undeleted
278 let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
279 expect(alphaPost2.post_view.post.removed).toBe(false);
280 assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
281 await unfollowRemotes(alpha);
284 test('Search for a post', async () => {
285 await unfollowRemotes(alpha);
286 let postRes = await createPost(alpha, betaCommunity.community.id);
287 expect(postRes.post_view.post).toBeDefined();
289 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
291 expect(betaPost.post.name).toBeDefined();
294 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
295 let postRes = await createPost(alpha, betaCommunity.community.id);
296 expect(postRes.post_view.post).toBeDefined();
298 let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
299 expect(betaPost.post.name).toBeDefined();
302 test('Enforce site ban for federated user', async () => {
303 // create a test user
304 let alphaUserJwt = await registerUser(alpha);
305 expect(alphaUserJwt).toBeDefined();
306 let alphaUser: API = {
307 client: alpha.client,
308 auth: alphaUserJwt.jwt,
310 let alphaUserActorId = (await getSite(alphaUser)).my_user.local_user_view.person.actor_id;
311 expect(alphaUserActorId).toBeDefined();
312 let alphaPerson = (await resolvePerson(alphaUser, alphaUserActorId)).person;
313 expect(alphaPerson).toBeDefined();
315 // alpha makes post in beta community, it federates to beta instance
316 let postRes1 = await createPost(alphaUser, betaCommunity.community.id);
317 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
318 expect(searchBeta1.posts[0]).toBeDefined();
320 // ban alpha from its instance
321 let banAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, true, true);
322 expect(banAlpha.banned).toBe(true);
324 // alpha ban should be federated to beta
325 let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
326 expect(alphaUserOnBeta1.person.person.banned).toBe(true);
328 // existing alpha post should be removed on beta
329 let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
330 expect(searchBeta2.posts[0]).toBeUndefined();
333 let unBanAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, false, false);
334 expect(unBanAlpha.banned).toBe(false);
336 // alpha makes new post in beta community, it federates
337 let postRes2 = await createPost(alphaUser, betaCommunity.community.id);
338 let searchBeta3 = await searchPostLocal(beta, postRes2.post_view.post);
339 expect(searchBeta3.posts[0]).toBeDefined();
341 let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId)
342 expect(alphaUserOnBeta2.person.person.banned).toBe(false);
345 test('Enforce community ban for federated user', async () => {
346 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
347 let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
348 expect(alphaPerson).toBeDefined();
350 // make a post in beta, it goes through
351 let postRes1 = await createPost(alpha, betaCommunity.community.id);
352 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
353 expect(searchBeta1.posts[0]).toBeDefined();
355 // ban alpha from beta community
356 let banAlpha = await banPersonFromCommunity(beta, alphaPerson.person.id, 2, true, true);
357 expect(banAlpha.banned).toBe(true);
359 // ensure that the post by alpha got removed
360 let searchAlpha1 = await searchPostLocal(alpha, postRes1.post_view.post);
361 expect(searchAlpha1.posts[0]).toBeUndefined();
363 // Alpha tries to make post on beta, but it fails because of ban
364 let postRes2 = await createPost(alpha, betaCommunity.community.id);
365 expect(postRes2.post_view).toBeUndefined();
368 let unBanAlpha = await banPersonFromCommunity(
370 alphaPerson.person.id,
375 expect(unBanAlpha.banned).toBe(false);
376 let postRes3 = await createPost(alpha, betaCommunity.community.id);
377 expect(postRes3.post_view.post).toBeDefined();
378 expect(postRes3.post_view.community.local).toBe(false);
379 expect(postRes3.post_view.creator.local).toBe(true);
380 expect(postRes3.post_view.counts.score).toBe(1);
382 // Make sure that post makes it to beta community
383 let searchBeta2 = await searchPostLocal(beta, postRes3.post_view.post);
384 expect(searchBeta2.posts[0]).toBeDefined();
387 test('Report a post', async () => {
388 let betaCommunity = (await resolveBetaCommunity(beta)).community;
389 let postRes = await createPost(beta, betaCommunity.community.id);
390 expect(postRes.post_view.post).toBeDefined();
392 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
393 let alphaReport = (await reportPost(alpha, alphaPost.post.id, randomString(10)))
394 .post_report_view.post_report;
396 let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
397 expect(betaReport).toBeDefined();
398 expect(betaReport.resolved).toBe(false);
399 expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
400 expect(betaReport.original_post_url).toBe(alphaReport.original_post_url);
401 expect(betaReport.original_post_body).toBe(alphaReport.original_post_body);
402 expect(betaReport.reason).toBe(alphaReport.reason);