1 jest.setTimeout(120000);
2 import {None} from '@sniptt/monads';
3 import { PostView, CommunityView } from 'lemmy-js-client';
28 banPersonFromCommunity,
38 let betaCommunity: CommunityView;
40 beforeAll(async () => {
42 betaCommunity = (await resolveBetaCommunity(alpha)).community.unwrap();
43 expect(betaCommunity).toBeDefined();
47 afterAll(async () => {
51 function assertPostFederation(postOne: PostView, postTwo: PostView) {
52 expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
53 expect(postOne.post.name).toBe(postTwo.post.name);
54 expect(postOne.post.body.unwrapOr("none")).toBe(postTwo.post.body.unwrapOr("none"));
55 expect(postOne.post.url.unwrapOr("none")).toBe(postTwo.post.url.unwrapOr("none"));
56 expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
57 expect(postOne.post.embed_title.unwrapOr("none")).toBe(postTwo.post.embed_title.unwrapOr("none"));
58 expect(postOne.post.embed_description.unwrapOr("none")).toBe(postTwo.post.embed_description.unwrapOr("none"));
59 expect(postOne.post.embed_html.unwrapOr("none")).toBe(postTwo.post.embed_html.unwrapOr("none"));
60 expect(postOne.post.published).toBe(postTwo.post.published);
61 expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
62 expect(postOne.post.locked).toBe(postTwo.post.locked);
63 expect(postOne.post.removed).toBe(postTwo.post.removed);
64 expect(postOne.post.deleted).toBe(postTwo.post.deleted);
67 test('Create a post', async () => {
68 let postRes = await createPost(alpha, betaCommunity.community.id);
69 expect(postRes.post_view.post).toBeDefined();
70 expect(postRes.post_view.community.local).toBe(false);
71 expect(postRes.post_view.creator.local).toBe(true);
72 expect(postRes.post_view.counts.score).toBe(1);
74 // Make sure that post is liked on beta
75 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
77 expect(betaPost).toBeDefined();
78 expect(betaPost.community.local).toBe(true);
79 expect(betaPost.creator.local).toBe(false);
80 expect(betaPost.counts.score).toBe(1);
81 assertPostFederation(betaPost, postRes.post_view);
83 // Delta only follows beta, so it should not see an alpha ap_id
84 let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
85 expect(deltaPost.isNone()).toBe(true)
87 // Epsilon has alpha blocked, it should not see the alpha post
88 let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
89 expect(epsilonPost.isNone()).toBe(true);
92 test('Create a post in a non-existent community', async () => {
93 let postRes = await createPost(alpha, -2) as any;
94 expect(postRes.error).toBe('couldnt_find_community');
97 test('Unlike a post', async () => {
98 let postRes = await createPost(alpha, betaCommunity.community.id);
99 let unlike = await likePost(alpha, 0, postRes.post_view.post);
100 expect(unlike.post_view.counts.score).toBe(0);
102 // Try to unlike it again, make sure it stays at 0
103 let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
104 expect(unlike2.post_view.counts.score).toBe(0);
106 // Make sure that post is unliked on beta
107 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
108 expect(betaPost).toBeDefined();
109 expect(betaPost.community.local).toBe(true);
110 expect(betaPost.creator.local).toBe(false);
111 expect(betaPost.counts.score).toBe(0);
112 assertPostFederation(betaPost, postRes.post_view);
115 test('Update a post', async () => {
116 let postRes = await createPost(alpha, betaCommunity.community.id);
118 let updatedName = 'A jest test federated post, updated';
119 let updatedPost = await editPost(alpha, postRes.post_view.post);
120 expect(updatedPost.post_view.post.name).toBe(updatedName);
121 expect(updatedPost.post_view.community.local).toBe(false);
122 expect(updatedPost.post_view.creator.local).toBe(true);
124 // Make sure that post is updated on beta
125 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
126 expect(betaPost.community.local).toBe(true);
127 expect(betaPost.creator.local).toBe(false);
128 expect(betaPost.post.name).toBe(updatedName);
129 assertPostFederation(betaPost, updatedPost.post_view);
131 // Make sure lemmy beta cannot update the post
132 let updatedPostBeta = await editPost(beta, betaPost.post) as any;
133 expect(updatedPostBeta.error).toBe('no_post_edit_allowed');
136 test('Sticky a post', async () => {
137 let postRes = await createPost(alpha, betaCommunity.community.id);
139 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
140 let stickiedPostRes = await stickyPost(beta, true, betaPost1.post);
141 expect(stickiedPostRes.post_view.post.stickied).toBe(true);
143 // Make sure that post is stickied on beta
144 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
145 expect(betaPost.community.local).toBe(true);
146 expect(betaPost.creator.local).toBe(false);
147 expect(betaPost.post.stickied).toBe(true);
150 let unstickiedPost = await stickyPost(beta, false, betaPost1.post);
151 expect(unstickiedPost.post_view.post.stickied).toBe(false);
153 // Make sure that post is unstickied on beta
154 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
155 expect(betaPost2.community.local).toBe(true);
156 expect(betaPost2.creator.local).toBe(false);
157 expect(betaPost2.post.stickied).toBe(false);
159 // Make sure that gamma cannot sticky the post on beta
160 let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post.unwrap();
161 let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
162 let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
163 expect(gammaTrySticky.post_view.post.stickied).toBe(true);
164 expect(betaPost3.post.stickied).toBe(false);
167 test('Lock a post', async () => {
168 await followCommunity(alpha, true, betaCommunity.community.id);
169 let postRes = await createPost(alpha, betaCommunity.community.id);
172 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
173 let lockedPostRes = await lockPost(beta, true, betaPost1.post);
174 expect(lockedPostRes.post_view.post.locked).toBe(true);
176 // Make sure that post is locked on alpha
177 let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
178 let alphaPost1 = searchAlpha.posts[0];
179 expect(alphaPost1.post.locked).toBe(true);
181 // Try to make a new comment there, on alpha
182 let comment: any = await createComment(alpha, alphaPost1.post.id, None);
183 expect(comment['error']).toBe('locked');
186 let unlockedPost = await lockPost(beta, false, betaPost1.post);
187 expect(unlockedPost.post_view.post.locked).toBe(false);
189 // Make sure that post is unlocked on alpha
190 let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
191 let alphaPost2 = searchAlpha2.posts[0];
192 expect(alphaPost2.community.local).toBe(false);
193 expect(alphaPost2.creator.local).toBe(true);
194 expect(alphaPost2.post.locked).toBe(false);
196 // Try to create a new comment, on alpha
197 let commentAlpha = await createComment(alpha, alphaPost1.post.id, None);
198 expect(commentAlpha).toBeDefined();
201 test('Delete a post', async () => {
202 let postRes = await createPost(alpha, betaCommunity.community.id);
203 expect(postRes.post_view.post).toBeDefined();
205 let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
206 expect(deletedPost.post_view.post.deleted).toBe(true);
207 expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
209 // Make sure lemmy beta sees post is deleted
210 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
211 // This will be undefined because of the tombstone
212 expect(betaPost.isNone()).toBe(true);
215 let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
216 expect(undeletedPost.post_view.post.deleted).toBe(false);
218 // Make sure lemmy beta sees post is undeleted
219 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
220 expect(betaPost2.post.deleted).toBe(false);
221 assertPostFederation(betaPost2, undeletedPost.post_view);
223 // Make sure lemmy beta cannot delete the post
224 let deletedPostBeta = await deletePost(beta, true, betaPost2.post) as any;
225 expect(deletedPostBeta.error).toStrictEqual('no_post_edit_allowed');
228 test('Remove a post from admin and community on different instance', async () => {
229 let postRes = await createPost(gamma, betaCommunity.community.id);
231 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post.unwrap();
232 let removedPost = await removePost(alpha, true, alphaPost.post);
233 expect(removedPost.post_view.post.removed).toBe(true);
234 expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
236 // Make sure lemmy beta sees post is NOT removed
237 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
238 expect(betaPost.post.removed).toBe(false);
241 let undeletedPost = await removePost(alpha, false, alphaPost.post);
242 expect(undeletedPost.post_view.post.removed).toBe(false);
244 // Make sure lemmy beta sees post is undeleted
245 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
246 expect(betaPost2.post.removed).toBe(false);
247 assertPostFederation(betaPost2, undeletedPost.post_view);
250 test('Remove a post from admin and community on same instance', async () => {
251 await followBeta(alpha);
252 let postRes = await createPost(alpha, betaCommunity.community.id);
253 expect(postRes.post_view.post).toBeDefined();
255 // Get the id for beta
256 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
257 let betaPost = searchBeta.posts[0];
258 expect(betaPost).toBeDefined();
260 // The beta admin removes it (the community lives on beta)
261 let removePostRes = await removePost(beta, true, betaPost.post);
262 expect(removePostRes.post_view.post.removed).toBe(true);
264 // Make sure lemmy alpha sees post is removed
265 // let alphaPost = await getPost(alpha, postRes.post_view.post.id);
266 // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
267 // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
270 let undeletedPost = await removePost(beta, false, betaPost.post);
271 expect(undeletedPost.post_view.post.removed).toBe(false);
273 // Make sure lemmy alpha sees post is undeleted
274 let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
275 expect(alphaPost2.post_view.post.removed).toBe(false);
276 assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
277 await unfollowRemotes(alpha);
280 test('Search for a post', async () => {
281 await unfollowRemotes(alpha);
282 let postRes = await createPost(alpha, betaCommunity.community.id);
283 expect(postRes.post_view.post).toBeDefined();
285 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
286 expect(betaPost.post.name).toBeDefined();
289 test('Enforce site ban for federated user', async () => {
290 // create a test user
291 let alphaUserJwt = await registerUser(alpha);
292 expect(alphaUserJwt).toBeDefined();
293 let alpha_user: API = {
294 client: alpha.client,
295 auth: alphaUserJwt.jwt,
297 let alphaUserActorId = (await getSite(alpha_user)).my_user.unwrap().local_user_view.person.actor_id;
298 expect(alphaUserActorId).toBeDefined();
299 let alphaPerson = (await resolvePerson(alpha_user, alphaUserActorId)).person.unwrap();
300 expect(alphaPerson).toBeDefined();
302 // alpha makes post in beta community, it federates to beta instance
303 let postRes1 = await createPost(alpha_user, betaCommunity.community.id);
304 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
305 expect(searchBeta1.posts[0]).toBeDefined();
307 // ban alpha from its instance
308 let banAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, true, true);
309 expect(banAlpha.banned).toBe(true);
311 // alpha ban should be federated to beta
312 let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
313 expect(alphaUserOnBeta1.person.unwrap().person.banned).toBe(true);
315 // existing alpha post should be removed on beta
316 let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
317 expect(searchBeta2.posts[0]).toBeUndefined();
320 let unBanAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, false, false);
321 expect(unBanAlpha.banned).toBe(false);
323 // alpha makes new post in beta community, it federates
324 let postRes2 = await createPost(alpha_user, betaCommunity.community.id);
325 let searchBeta3 = await searchPostLocal(beta, postRes2.post_view.post);
326 expect(searchBeta3.posts[0]).toBeDefined();
328 let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId)
329 expect(alphaUserOnBeta2.person.unwrap().person.banned).toBe(false);
332 test('Enforce community ban for federated user', async () => {
333 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
334 let alphaPerson = (await resolvePerson(beta, alphaShortname)).person.unwrap();
335 expect(alphaPerson).toBeDefined();
337 // make a post in beta, it goes through
338 let postRes1 = await createPost(alpha, betaCommunity.community.id);
339 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
340 expect(searchBeta1.posts[0]).toBeDefined();
342 // ban alpha from beta community
343 let banAlpha = await banPersonFromCommunity(beta, alphaPerson.person.id, 2, true, true);
344 expect(banAlpha.banned).toBe(true);
346 // ensure that the post by alpha got removed
347 let searchAlpha1 = await searchPostLocal(alpha, postRes1.post_view.post);
348 expect(searchAlpha1.posts[0]).toBeUndefined();
350 // Alpha tries to make post on beta, but it fails because of ban
351 let postRes2 = await createPost(alpha, betaCommunity.community.id);
352 expect(postRes2.post_view).toBeUndefined();
355 let unBanAlpha = await banPersonFromCommunity(
357 alphaPerson.person.id,
362 expect(unBanAlpha.banned).toBe(false);
363 let postRes3 = await createPost(alpha, betaCommunity.community.id);
364 expect(postRes3.post_view.post).toBeDefined();
365 expect(postRes3.post_view.community.local).toBe(false);
366 expect(postRes3.post_view.creator.local).toBe(true);
367 expect(postRes3.post_view.counts.score).toBe(1);
369 // Make sure that post makes it to beta community
370 let searchBeta2 = await searchPostLocal(beta, postRes3.post_view.post);
371 expect(searchBeta2.posts[0]).toBeDefined();
375 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
376 let postRes = await createPost(alpha, betaCommunity.community.id);
377 expect(postRes.post_view.post).toBeDefined();
379 let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post.unwrap();
380 expect(betaPost.post.name).toBeDefined();
383 test('Report a post', async () => {
384 let betaCommunity = (await resolveBetaCommunity(beta)).community.unwrap();
385 let postRes = await createPost(beta, betaCommunity.community.id);
386 expect(postRes.post_view.post).toBeDefined();
388 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post.unwrap();
389 let alphaReport = (await reportPost(alpha, alphaPost.post.id, randomString(10)))
390 .post_report_view.post_report;
392 let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
393 expect(betaReport).toBeDefined();
394 expect(betaReport.resolved).toBe(false);
395 expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
396 expect(betaReport.original_post_url.unwrapOr("none")).toBe(alphaReport.original_post_url.unwrapOr("none"));
397 expect(betaReport.original_post_body.unwrapOr("none")).toBe(alphaReport.original_post_body.unwrapOr("none"));
398 expect(betaReport.reason).toBe(alphaReport.reason);