1 jest.setTimeout(120000);
26 banPersonFromCommunity,
35 import { PostView, CommunityView } from 'lemmy-js-client';
37 let betaCommunity: CommunityView;
39 beforeAll(async () => {
41 betaCommunity = (await resolveBetaCommunity(alpha)).community;
42 expect(betaCommunity).toBeDefined();
46 afterAll(async () => {
50 function assertPostFederation(postOne: PostView, postTwo: PostView) {
51 expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
52 expect(postOne.post.name).toBe(postTwo.post.name);
53 expect(postOne.post.body).toBe(postTwo.post.body);
54 expect(postOne.post.url).toBe(postTwo.post.url);
55 expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
56 expect(postOne.post.embed_title).toBe(postTwo.post.embed_title);
57 expect(postOne.post.embed_description).toBe(postTwo.post.embed_description);
58 expect(postOne.post.embed_html).toBe(postTwo.post.embed_html);
59 expect(postOne.post.published).toBe(postTwo.post.published);
60 expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
61 expect(postOne.post.locked).toBe(postTwo.post.locked);
62 expect(postOne.post.removed).toBe(postTwo.post.removed);
63 expect(postOne.post.deleted).toBe(postTwo.post.deleted);
66 test('Create a post', async () => {
67 let postRes = await createPost(alpha, betaCommunity.community.id);
68 expect(postRes.post_view.post).toBeDefined();
69 expect(postRes.post_view.community.local).toBe(false);
70 expect(postRes.post_view.creator.local).toBe(true);
71 expect(postRes.post_view.counts.score).toBe(1);
73 // Make sure that post is liked on beta
74 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
76 expect(betaPost).toBeDefined();
77 expect(betaPost.community.local).toBe(true);
78 expect(betaPost.creator.local).toBe(false);
79 expect(betaPost.counts.score).toBe(1);
80 assertPostFederation(betaPost, postRes.post_view);
82 // Delta only follows beta, so it should not see an alpha ap_id
83 let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
84 expect(deltaPost).toBeUndefined();
86 // Epsilon has alpha blocked, it should not see the alpha post
87 let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
88 expect(epsilonPost).toBeUndefined();
91 test('Create a post in a non-existent community', async () => {
92 let postRes = await createPost(alpha, -2);
93 expect(postRes).toStrictEqual({ error: 'couldnt_find_community' });
96 test('Unlike a post', async () => {
97 let postRes = await createPost(alpha, betaCommunity.community.id);
98 let unlike = await likePost(alpha, 0, postRes.post_view.post);
99 expect(unlike.post_view.counts.score).toBe(0);
101 // Try to unlike it again, make sure it stays at 0
102 let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
103 expect(unlike2.post_view.counts.score).toBe(0);
105 // Make sure that post is unliked on beta
106 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
107 expect(betaPost).toBeDefined();
108 expect(betaPost.community.local).toBe(true);
109 expect(betaPost.creator.local).toBe(false);
110 expect(betaPost.counts.score).toBe(0);
111 assertPostFederation(betaPost, postRes.post_view);
114 test('Update a post', async () => {
115 let postRes = await createPost(alpha, betaCommunity.community.id);
117 let updatedName = 'A jest test federated post, updated';
118 let updatedPost = await editPost(alpha, postRes.post_view.post);
119 expect(updatedPost.post_view.post.name).toBe(updatedName);
120 expect(updatedPost.post_view.community.local).toBe(false);
121 expect(updatedPost.post_view.creator.local).toBe(true);
123 // Make sure that post is updated on beta
124 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
125 expect(betaPost.community.local).toBe(true);
126 expect(betaPost.creator.local).toBe(false);
127 expect(betaPost.post.name).toBe(updatedName);
128 assertPostFederation(betaPost, updatedPost.post_view);
130 // Make sure lemmy beta cannot update the post
131 let updatedPostBeta = await editPost(beta, betaPost.post);
132 expect(updatedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
135 test('Sticky a post', async () => {
136 let postRes = await createPost(alpha, betaCommunity.community.id);
138 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
139 let stickiedPostRes = await stickyPost(beta, true, betaPost1.post);
140 expect(stickiedPostRes.post_view.post.stickied).toBe(true);
142 // Make sure that post is stickied on beta
143 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
144 expect(betaPost.community.local).toBe(true);
145 expect(betaPost.creator.local).toBe(false);
146 expect(betaPost.post.stickied).toBe(true);
149 let unstickiedPost = await stickyPost(beta, false, betaPost1.post);
150 expect(unstickiedPost.post_view.post.stickied).toBe(false);
152 // Make sure that post is unstickied on beta
153 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
154 expect(betaPost2.community.local).toBe(true);
155 expect(betaPost2.creator.local).toBe(false);
156 expect(betaPost2.post.stickied).toBe(false);
158 // Make sure that gamma cannot sticky the post on beta
159 let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
160 let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
161 let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post;
162 expect(gammaTrySticky.post_view.post.stickied).toBe(true);
163 expect(betaPost3.post.stickied).toBe(false);
166 test('Lock a post', async () => {
167 await followCommunity(alpha, true, betaCommunity.community.id);
168 let postRes = await createPost(alpha, betaCommunity.community.id);
171 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
172 let lockedPostRes = await lockPost(beta, true, betaPost1.post);
173 expect(lockedPostRes.post_view.post.locked).toBe(true);
175 // Make sure that post is locked on alpha
176 let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
177 let alphaPost1 = searchAlpha.posts[0];
178 expect(alphaPost1.post.locked).toBe(true);
180 // Try to make a new comment there, on alpha
181 let comment: any = await createComment(alpha, alphaPost1.post.id);
182 expect(comment['error']).toBe('locked');
185 let unlockedPost = await lockPost(beta, false, betaPost1.post);
186 expect(unlockedPost.post_view.post.locked).toBe(false);
188 // Make sure that post is unlocked on alpha
189 let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
190 let alphaPost2 = searchAlpha2.posts[0];
191 expect(alphaPost2.community.local).toBe(false);
192 expect(alphaPost2.creator.local).toBe(true);
193 expect(alphaPost2.post.locked).toBe(false);
195 // Try to create a new comment, on alpha
196 let commentAlpha = await createComment(alpha, alphaPost1.post.id);
197 expect(commentAlpha).toBeDefined();
200 test('Delete a post', async () => {
201 let postRes = await createPost(alpha, betaCommunity.community.id);
202 expect(postRes.post_view.post).toBeDefined();
204 let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
205 expect(deletedPost.post_view.post.deleted).toBe(true);
206 expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
208 // Make sure lemmy beta sees post is deleted
209 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
210 // This will be undefined because of the tombstone
211 expect(betaPost).toBeUndefined();
214 let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
215 expect(undeletedPost.post_view.post.deleted).toBe(false);
217 // Make sure lemmy beta sees post is undeleted
218 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
219 expect(betaPost2.post.deleted).toBe(false);
220 assertPostFederation(betaPost2, undeletedPost.post_view);
222 // Make sure lemmy beta cannot delete the post
223 let deletedPostBeta = await deletePost(beta, true, betaPost2.post);
224 expect(deletedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
227 test('Remove a post from admin and community on different instance', async () => {
228 let postRes = await createPost(alpha, betaCommunity.community.id);
230 let removedPost = await removePost(alpha, true, postRes.post_view.post);
231 expect(removedPost.post_view.post.removed).toBe(true);
232 expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
234 // Make sure lemmy beta sees post is NOT removed
235 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
236 expect(betaPost.post.removed).toBe(false);
239 let undeletedPost = await removePost(alpha, false, postRes.post_view.post);
240 expect(undeletedPost.post_view.post.removed).toBe(false);
242 // Make sure lemmy beta sees post is undeleted
243 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
244 expect(betaPost2.post.removed).toBe(false);
245 assertPostFederation(betaPost2, undeletedPost.post_view);
248 test('Remove a post from admin and community on same instance', async () => {
249 await followBeta(alpha);
250 let postRes = await createPost(alpha, betaCommunity.community.id);
251 expect(postRes.post_view.post).toBeDefined();
253 // Get the id for beta
254 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
255 let betaPost = searchBeta.posts[0];
256 expect(betaPost).toBeDefined();
258 // The beta admin removes it (the community lives on beta)
259 let removePostRes = await removePost(beta, true, betaPost.post);
260 expect(removePostRes.post_view.post.removed).toBe(true);
262 // Make sure lemmy alpha sees post is removed
263 let alphaPost = await getPost(alpha, postRes.post_view.post.id);
264 // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
265 // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
268 let undeletedPost = await removePost(beta, false, betaPost.post);
269 expect(undeletedPost.post_view.post.removed).toBe(false);
271 // Make sure lemmy alpha sees post is undeleted
272 let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
273 expect(alphaPost2.post_view.post.removed).toBe(false);
274 assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
275 await unfollowRemotes(alpha);
278 test('Search for a post', async () => {
279 await unfollowRemotes(alpha);
280 let postRes = await createPost(alpha, betaCommunity.community.id);
281 expect(postRes.post_view.post).toBeDefined();
283 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
285 expect(betaPost.post.name).toBeDefined();
288 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
289 let postRes = await createPost(alpha, betaCommunity.community.id);
290 expect(postRes.post_view.post).toBeDefined();
292 let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
293 expect(betaPost.post.name).toBeDefined();
296 test('Enforce site ban for federated user', async () => {
297 // create a test user
298 let alphaUserJwt = await registerUser(alpha);
299 expect(alphaUserJwt).toBeDefined();
300 let alphaUser: API = {
301 client: alpha.client,
302 auth: alphaUserJwt.jwt,
304 let alphaUserActorId = (await getSite(alphaUser)).my_user.local_user_view.person.actor_id;
305 expect(alphaUserActorId).toBeDefined();
306 let alphaPerson = (await resolvePerson(alphaUser, alphaUserActorId)).person;
307 expect(alphaPerson).toBeDefined();
309 // alpha makes post in beta community, it federates to beta instance
310 let postRes1 = await createPost(alphaUser, betaCommunity.community.id);
311 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
312 expect(searchBeta1.posts[0]).toBeDefined();
314 // ban alpha from its instance
315 let banAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, true, true);
316 expect(banAlpha.banned).toBe(true);
318 // alpha ban should be federated to beta
319 let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
320 expect(alphaUserOnBeta1.person.person.banned).toBe(true);
322 // existing alpha post should be removed on beta
323 let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
324 expect(searchBeta2.posts[0]).toBeUndefined();
327 let unBanAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, false, false);
328 expect(unBanAlpha.banned).toBe(false);
330 // alpha makes new post in beta community, it federates
331 let postRes2 = await createPost(alphaUser, betaCommunity.community.id);
332 let searchBeta3 = await searchPostLocal(beta, postRes2.post_view.post);
333 expect(searchBeta3.posts[0]).toBeDefined();
335 let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId)
336 expect(alphaUserOnBeta2.person.person.banned).toBe(false);
339 test('Enforce community ban for federated user', async () => {
340 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
341 let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
342 expect(alphaPerson).toBeDefined();
344 // make a post in beta, it goes through
345 let postRes1 = await createPost(alpha, betaCommunity.community.id);
346 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
347 expect(searchBeta1.posts[0]).toBeDefined();
349 // ban alpha from beta community
350 let banAlpha = await banPersonFromCommunity(beta, alphaPerson.person.id, 2, true, true);
351 expect(banAlpha.banned).toBe(true);
353 // ensure that the post by alpha got removed
354 let searchAlpha1 = await searchPostLocal(alpha, postRes1.post_view.post);
355 expect(searchAlpha1.posts[0]).toBeUndefined();
357 // Alpha tries to make post on beta, but it fails because of ban
358 let postRes2 = await createPost(alpha, betaCommunity.community.id);
359 expect(postRes2.post_view).toBeUndefined();
362 let unBanAlpha = await banPersonFromCommunity(
364 alphaPerson.person.id,
369 expect(unBanAlpha.banned).toBe(false);
370 let postRes3 = await createPost(alpha, betaCommunity.community.id);
371 expect(postRes3.post_view.post).toBeDefined();
372 expect(postRes3.post_view.community.local).toBe(false);
373 expect(postRes3.post_view.creator.local).toBe(true);
374 expect(postRes3.post_view.counts.score).toBe(1);
376 // Make sure that post makes it to beta community
377 let searchBeta2 = await searchPostLocal(beta, postRes3.post_view.post);
378 expect(searchBeta2.posts[0]).toBeDefined();
381 test('Report a post', async () => {
382 let betaCommunity = (await resolveBetaCommunity(beta)).community;
383 let postRes = await createPost(beta, betaCommunity.community.id);
384 expect(postRes.post_view.post).toBeDefined();
386 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
387 let alphaReport = (await reportPost(alpha, alphaPost.post.id, randomString(10)))
388 .post_report_view.post_report;
390 let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
391 expect(betaReport).toBeDefined();
392 expect(betaReport.resolved).toBe(false);
393 expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
394 expect(betaReport.original_post_url).toBe(alphaReport.original_post_url);
395 expect(betaReport.original_post_body).toBe(alphaReport.original_post_body);
396 expect(betaReport.reason).toBe(alphaReport.reason);