1 jest.setTimeout(120000);
2 import {None} from '@sniptt/monads';
3 import { PostView, CommunityView } from 'lemmy-js-client';
28 banPersonFromCommunity,
39 let betaCommunity: CommunityView;
41 beforeAll(async () => {
43 betaCommunity = (await resolveBetaCommunity(alpha)).community.unwrap();
44 expect(betaCommunity).toBeDefined();
48 afterAll(async () => {
52 function assertPostFederation(postOne: PostView, postTwo: PostView) {
53 expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
54 expect(postOne.post.name).toBe(postTwo.post.name);
55 expect(postOne.post.body.unwrapOr("none")).toBe(postTwo.post.body.unwrapOr("none"));
56 expect(postOne.post.url.unwrapOr("none")).toBe(postTwo.post.url.unwrapOr("none"));
57 expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
58 expect(postOne.post.embed_title.unwrapOr("none")).toBe(postTwo.post.embed_title.unwrapOr("none"));
59 expect(postOne.post.embed_description.unwrapOr("none")).toBe(postTwo.post.embed_description.unwrapOr("none"));
60 expect(postOne.post.embed_html.unwrapOr("none")).toBe(postTwo.post.embed_html.unwrapOr("none"));
61 expect(postOne.post.published).toBe(postTwo.post.published);
62 expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
63 expect(postOne.post.locked).toBe(postTwo.post.locked);
64 expect(postOne.post.removed).toBe(postTwo.post.removed);
65 expect(postOne.post.deleted).toBe(postTwo.post.deleted);
68 test('Create a post', async () => {
69 let postRes = await createPost(alpha, betaCommunity.community.id);
70 expect(postRes.post_view.post).toBeDefined();
71 expect(postRes.post_view.community.local).toBe(false);
72 expect(postRes.post_view.creator.local).toBe(true);
73 expect(postRes.post_view.counts.score).toBe(1);
75 // Make sure that post is liked on beta
76 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
78 expect(betaPost).toBeDefined();
79 expect(betaPost.community.local).toBe(true);
80 expect(betaPost.creator.local).toBe(false);
81 expect(betaPost.counts.score).toBe(1);
82 assertPostFederation(betaPost, postRes.post_view);
84 // Delta only follows beta, so it should not see an alpha ap_id
85 let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
86 expect(deltaPost.isNone()).toBe(true)
88 // Epsilon has alpha blocked, it should not see the alpha post
89 let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
90 expect(epsilonPost.isNone()).toBe(true);
93 test('Create a post in a non-existent community', async () => {
94 let postRes = await createPost(alpha, -2) as any;
95 expect(postRes.error).toBe('couldnt_find_community');
98 test('Unlike a post', async () => {
99 let postRes = await createPost(alpha, betaCommunity.community.id);
100 let unlike = await likePost(alpha, 0, postRes.post_view.post);
101 expect(unlike.post_view.counts.score).toBe(0);
103 // Try to unlike it again, make sure it stays at 0
104 let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
105 expect(unlike2.post_view.counts.score).toBe(0);
107 // Make sure that post is unliked on beta
108 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
109 expect(betaPost).toBeDefined();
110 expect(betaPost.community.local).toBe(true);
111 expect(betaPost.creator.local).toBe(false);
112 expect(betaPost.counts.score).toBe(0);
113 assertPostFederation(betaPost, postRes.post_view);
116 test('Update a post', async () => {
117 let postRes = await createPost(alpha, betaCommunity.community.id);
119 let updatedName = 'A jest test federated post, updated';
120 let updatedPost = await editPost(alpha, postRes.post_view.post);
121 expect(updatedPost.post_view.post.name).toBe(updatedName);
122 expect(updatedPost.post_view.community.local).toBe(false);
123 expect(updatedPost.post_view.creator.local).toBe(true);
125 // Make sure that post is updated on beta
126 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
127 expect(betaPost.community.local).toBe(true);
128 expect(betaPost.creator.local).toBe(false);
129 expect(betaPost.post.name).toBe(updatedName);
130 assertPostFederation(betaPost, updatedPost.post_view);
132 // Make sure lemmy beta cannot update the post
133 let updatedPostBeta = await editPost(beta, betaPost.post) as any;
134 expect(updatedPostBeta.error).toBe('no_post_edit_allowed');
137 test('Sticky a post', async () => {
138 let postRes = await createPost(alpha, betaCommunity.community.id);
140 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
141 let stickiedPostRes = await stickyPost(beta, true, betaPost1.post);
142 expect(stickiedPostRes.post_view.post.stickied).toBe(true);
144 // Make sure that post is stickied on beta
145 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
146 expect(betaPost.community.local).toBe(true);
147 expect(betaPost.creator.local).toBe(false);
148 expect(betaPost.post.stickied).toBe(true);
151 let unstickiedPost = await stickyPost(beta, false, betaPost1.post);
152 expect(unstickiedPost.post_view.post.stickied).toBe(false);
154 // Make sure that post is unstickied on beta
155 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
156 expect(betaPost2.community.local).toBe(true);
157 expect(betaPost2.creator.local).toBe(false);
158 expect(betaPost2.post.stickied).toBe(false);
160 // Make sure that gamma cannot sticky the post on beta
161 let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post.unwrap();
162 let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
163 let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
164 expect(gammaTrySticky.post_view.post.stickied).toBe(true);
165 expect(betaPost3.post.stickied).toBe(false);
168 test('Lock a post', async () => {
169 await followCommunity(alpha, true, betaCommunity.community.id);
170 let postRes = await createPost(alpha, betaCommunity.community.id);
173 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
174 let lockedPostRes = await lockPost(beta, true, betaPost1.post);
175 expect(lockedPostRes.post_view.post.locked).toBe(true);
177 // Make sure that post is locked on alpha
178 let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
179 let alphaPost1 = searchAlpha.posts[0];
180 expect(alphaPost1.post.locked).toBe(true);
182 // Try to make a new comment there, on alpha
183 let comment: any = await createComment(alpha, alphaPost1.post.id, None);
184 expect(comment['error']).toBe('locked');
187 let unlockedPost = await lockPost(beta, false, betaPost1.post);
188 expect(unlockedPost.post_view.post.locked).toBe(false);
190 // Make sure that post is unlocked on alpha
191 let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
192 let alphaPost2 = searchAlpha2.posts[0];
193 expect(alphaPost2.community.local).toBe(false);
194 expect(alphaPost2.creator.local).toBe(true);
195 expect(alphaPost2.post.locked).toBe(false);
197 // Try to create a new comment, on alpha
198 let commentAlpha = await createComment(alpha, alphaPost1.post.id, None);
199 expect(commentAlpha).toBeDefined();
202 test('Delete a post', async () => {
203 let postRes = await createPost(alpha, betaCommunity.community.id);
204 expect(postRes.post_view.post).toBeDefined();
206 let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
207 expect(deletedPost.post_view.post.deleted).toBe(true);
208 expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
210 // Make sure lemmy beta sees post is deleted
211 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
212 // This will be undefined because of the tombstone
213 expect(betaPost.isNone()).toBe(true);
216 let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
217 expect(undeletedPost.post_view.post.deleted).toBe(false);
219 // Make sure lemmy beta sees post is undeleted
220 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
221 expect(betaPost2.post.deleted).toBe(false);
222 assertPostFederation(betaPost2, undeletedPost.post_view);
224 // Make sure lemmy beta cannot delete the post
225 let deletedPostBeta = await deletePost(beta, true, betaPost2.post) as any;
226 expect(deletedPostBeta.error).toStrictEqual('no_post_edit_allowed');
229 test('Remove a post from admin and community on different instance', async () => {
230 let gammaCommunity = await resolveCommunity(gamma, betaCommunity.community.actor_id);
231 let postRes = await createPost(gamma, gammaCommunity.community.unwrap().community.id);
233 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post.unwrap();
234 let removedPost = await removePost(alpha, true, alphaPost.post);
235 expect(removedPost.post_view.post.removed).toBe(true);
236 expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
238 // Make sure lemmy beta sees post is NOT removed
239 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
240 expect(betaPost.post.removed).toBe(false);
243 let undeletedPost = await removePost(alpha, false, alphaPost.post);
244 expect(undeletedPost.post_view.post.removed).toBe(false);
246 // Make sure lemmy beta sees post is undeleted
247 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
248 expect(betaPost2.post.removed).toBe(false);
249 assertPostFederation(betaPost2, undeletedPost.post_view);
252 test('Remove a post from admin and community on same instance', async () => {
253 await followBeta(alpha);
254 let postRes = await createPost(alpha, betaCommunity.community.id);
255 expect(postRes.post_view.post).toBeDefined();
257 // Get the id for beta
258 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
259 let betaPost = searchBeta.posts[0];
260 expect(betaPost).toBeDefined();
262 // The beta admin removes it (the community lives on beta)
263 let removePostRes = await removePost(beta, true, betaPost.post);
264 expect(removePostRes.post_view.post.removed).toBe(true);
266 // Make sure lemmy alpha sees post is removed
267 // let alphaPost = await getPost(alpha, postRes.post_view.post.id);
268 // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
269 // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
272 let undeletedPost = await removePost(beta, false, betaPost.post);
273 expect(undeletedPost.post_view.post.removed).toBe(false);
275 // Make sure lemmy alpha sees post is undeleted
276 let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
277 expect(alphaPost2.post_view.post.removed).toBe(false);
278 assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
279 await unfollowRemotes(alpha);
282 test('Search for a post', async () => {
283 await unfollowRemotes(alpha);
284 let postRes = await createPost(alpha, betaCommunity.community.id);
285 expect(postRes.post_view.post).toBeDefined();
287 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
288 expect(betaPost.post.name).toBeDefined();
291 test('Enforce site ban for federated user', async () => {
292 // create a test user
293 let alphaUserJwt = await registerUser(alpha);
294 expect(alphaUserJwt).toBeDefined();
295 let alpha_user: API = {
296 client: alpha.client,
297 auth: alphaUserJwt.jwt,
299 let alphaUserActorId = (await getSite(alpha_user)).my_user.unwrap().local_user_view.person.actor_id;
300 expect(alphaUserActorId).toBeDefined();
301 let alphaPerson = (await resolvePerson(alpha_user, alphaUserActorId)).person.unwrap();
302 expect(alphaPerson).toBeDefined();
304 // alpha makes post in beta community, it federates to beta instance
305 let postRes1 = await createPost(alpha_user, betaCommunity.community.id);
306 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
307 expect(searchBeta1.posts[0]).toBeDefined();
309 // ban alpha from its instance
310 let banAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, true, true);
311 expect(banAlpha.banned).toBe(true);
313 // alpha ban should be federated to beta
314 let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
315 expect(alphaUserOnBeta1.person.unwrap().person.banned).toBe(true);
317 // existing alpha post should be removed on beta
318 let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
319 expect(searchBeta2.posts[0]).toBeUndefined();
322 let unBanAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, false, false);
323 expect(unBanAlpha.banned).toBe(false);
325 // alpha makes new post in beta community, it federates
326 let postRes2 = await createPost(alpha_user, betaCommunity.community.id);
327 let searchBeta3 = await searchPostLocal(beta, postRes2.post_view.post);
328 expect(searchBeta3.posts[0]).toBeDefined();
330 let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId)
331 expect(alphaUserOnBeta2.person.unwrap().person.banned).toBe(false);
334 test('Enforce community ban for federated user', async () => {
335 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
336 let alphaPerson = (await resolvePerson(beta, alphaShortname)).person.unwrap();
337 expect(alphaPerson).toBeDefined();
339 // make a post in beta, it goes through
340 let postRes1 = await createPost(alpha, betaCommunity.community.id);
341 let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
342 expect(searchBeta1.posts[0]).toBeDefined();
344 // ban alpha from beta community
345 let banAlpha = await banPersonFromCommunity(beta, alphaPerson.person.id, 2, true, true);
346 expect(banAlpha.banned).toBe(true);
348 // ensure that the post by alpha got removed
349 let searchAlpha1 = await searchPostLocal(alpha, postRes1.post_view.post);
350 expect(searchAlpha1.posts[0]).toBeUndefined();
352 // Alpha tries to make post on beta, but it fails because of ban
353 let postRes2 = await createPost(alpha, betaCommunity.community.id);
354 expect(postRes2.post_view).toBeUndefined();
357 let unBanAlpha = await banPersonFromCommunity(
359 alphaPerson.person.id,
364 expect(unBanAlpha.banned).toBe(false);
365 let postRes3 = await createPost(alpha, betaCommunity.community.id);
366 expect(postRes3.post_view.post).toBeDefined();
367 expect(postRes3.post_view.community.local).toBe(false);
368 expect(postRes3.post_view.creator.local).toBe(true);
369 expect(postRes3.post_view.counts.score).toBe(1);
371 // Make sure that post makes it to beta community
372 let searchBeta2 = await searchPostLocal(beta, postRes3.post_view.post);
373 expect(searchBeta2.posts[0]).toBeDefined();
377 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
378 let postRes = await createPost(alpha, betaCommunity.community.id);
379 expect(postRes.post_view.post).toBeDefined();
381 let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post.unwrap();
382 expect(betaPost.post.name).toBeDefined();
385 test('Report a post', async () => {
386 let betaCommunity = (await resolveBetaCommunity(beta)).community.unwrap();
387 let postRes = await createPost(beta, betaCommunity.community.id);
388 expect(postRes.post_view.post).toBeDefined();
390 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post.unwrap();
391 let alphaReport = (await reportPost(alpha, alphaPost.post.id, randomString(10)))
392 .post_report_view.post_report;
394 let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
395 expect(betaReport).toBeDefined();
396 expect(betaReport.resolved).toBe(false);
397 expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
398 expect(betaReport.original_post_url.unwrapOr("none")).toBe(alphaReport.original_post_url.unwrapOr("none"));
399 expect(betaReport.original_post_body.unwrapOr("none")).toBe(alphaReport.original_post_body.unwrapOr("none"));
400 expect(betaReport.reason).toBe(alphaReport.reason);