1 jest.setTimeout(120000);
26 banPersonFromCommunity,
31 import { PostView, CommunityView } from 'lemmy-js-client';
33 let betaCommunity: CommunityView;
35 beforeAll(async () => {
37 betaCommunity = (await resolveBetaCommunity(alpha)).community;
38 expect(betaCommunity).toBeDefined();
42 afterAll(async () => {
46 async function unfollows() {
47 await unfollowRemotes(alpha);
48 await unfollowRemotes(gamma);
49 await unfollowRemotes(delta);
50 await unfollowRemotes(epsilon);
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 expect(postOne.post.url).toBe(postTwo.post.url);
58 expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
59 expect(postOne.post.embed_title).toBe(postTwo.post.embed_title);
60 expect(postOne.post.embed_description).toBe(postTwo.post.embed_description);
61 expect(postOne.post.embed_html).toBe(postTwo.post.embed_html);
62 expect(postOne.post.published).toBe(postTwo.post.published);
63 expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
64 expect(postOne.post.locked).toBe(postTwo.post.locked);
65 expect(postOne.post.removed).toBe(postTwo.post.removed);
66 expect(postOne.post.deleted).toBe(postTwo.post.deleted);
69 test('Create a post', async () => {
70 let postRes = await createPost(alpha, betaCommunity.community.id);
71 expect(postRes.post_view.post).toBeDefined();
72 expect(postRes.post_view.community.local).toBe(false);
73 expect(postRes.post_view.creator.local).toBe(true);
74 expect(postRes.post_view.counts.score).toBe(1);
76 // Make sure that post is liked on beta
77 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
79 expect(betaPost).toBeDefined();
80 expect(betaPost.community.local).toBe(true);
81 expect(betaPost.creator.local).toBe(false);
82 expect(betaPost.counts.score).toBe(1);
83 assertPostFederation(betaPost, postRes.post_view);
85 // Delta only follows beta, so it should not see an alpha ap_id
86 let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
87 expect(deltaPost).toBeUndefined();
89 // Epsilon has alpha blocked, it should not see the alpha post
90 let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
91 expect(epsilonPost).toBeUndefined();
94 test('Create a post in a non-existent community', async () => {
95 let postRes = await createPost(alpha, -2);
96 expect(postRes).toStrictEqual({ error: 'couldnt_find_community' });
99 test('Unlike a post', async () => {
100 let postRes = await createPost(alpha, betaCommunity.community.id);
101 let unlike = await likePost(alpha, 0, postRes.post_view.post);
102 expect(unlike.post_view.counts.score).toBe(0);
104 // Try to unlike it again, make sure it stays at 0
105 let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
106 expect(unlike2.post_view.counts.score).toBe(0);
108 // Make sure that post is unliked on beta
109 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
110 expect(betaPost).toBeDefined();
111 expect(betaPost.community.local).toBe(true);
112 expect(betaPost.creator.local).toBe(false);
113 expect(betaPost.counts.score).toBe(0);
114 assertPostFederation(betaPost, postRes.post_view);
117 test('Update a post', async () => {
118 let postRes = await createPost(alpha, betaCommunity.community.id);
120 let updatedName = 'A jest test federated post, updated';
121 let updatedPost = await editPost(alpha, postRes.post_view.post);
122 expect(updatedPost.post_view.post.name).toBe(updatedName);
123 expect(updatedPost.post_view.community.local).toBe(false);
124 expect(updatedPost.post_view.creator.local).toBe(true);
126 // Make sure that post is updated on beta
127 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
128 expect(betaPost.community.local).toBe(true);
129 expect(betaPost.creator.local).toBe(false);
130 expect(betaPost.post.name).toBe(updatedName);
131 assertPostFederation(betaPost, updatedPost.post_view);
133 // Make sure lemmy beta cannot update the post
134 let updatedPostBeta = await editPost(beta, betaPost.post);
135 expect(updatedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
138 test('Sticky a post', async () => {
139 let postRes = await createPost(alpha, betaCommunity.community.id);
141 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
142 let stickiedPostRes = await stickyPost(beta, true, betaPost1.post);
143 expect(stickiedPostRes.post_view.post.stickied).toBe(true);
145 // Make sure that post is stickied on beta
146 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
147 expect(betaPost.community.local).toBe(true);
148 expect(betaPost.creator.local).toBe(false);
149 expect(betaPost.post.stickied).toBe(true);
152 let unstickiedPost = await stickyPost(beta, false, betaPost1.post);
153 expect(unstickiedPost.post_view.post.stickied).toBe(false);
155 // Make sure that post is unstickied on beta
156 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
157 expect(betaPost2.community.local).toBe(true);
158 expect(betaPost2.creator.local).toBe(false);
159 expect(betaPost2.post.stickied).toBe(false);
161 // Make sure that gamma cannot sticky the post on beta
162 let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
163 let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
164 let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post;
165 expect(gammaTrySticky.post_view.post.stickied).toBe(true);
166 expect(betaPost3.post.stickied).toBe(false);
169 test('Lock a post', async () => {
170 await followCommunity(alpha, true, betaCommunity.community.id);
171 let postRes = await createPost(alpha, betaCommunity.community.id);
174 let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
175 let lockedPostRes = await lockPost(beta, true, betaPost1.post);
176 expect(lockedPostRes.post_view.post.locked).toBe(true);
178 // Make sure that post is locked on alpha
179 let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
180 let alphaPost1 = searchAlpha.posts[0];
181 expect(alphaPost1.post.locked).toBe(true);
183 // Try to make a new comment there, on alpha
184 let comment: any = await createComment(alpha, alphaPost1.post.id);
185 expect(comment['error']).toBe('locked');
188 let unlockedPost = await lockPost(beta, false, betaPost1.post);
189 expect(unlockedPost.post_view.post.locked).toBe(false);
191 // Make sure that post is unlocked on alpha
192 let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
193 let alphaPost2 = searchAlpha2.posts[0];
194 expect(alphaPost2.community.local).toBe(false);
195 expect(alphaPost2.creator.local).toBe(true);
196 expect(alphaPost2.post.locked).toBe(false);
198 // Try to create a new comment, on alpha
199 let commentAlpha = await createComment(alpha, alphaPost1.post.id);
200 expect(commentAlpha).toBeDefined();
203 test('Delete a post', async () => {
204 let postRes = await createPost(alpha, betaCommunity.community.id);
205 expect(postRes.post_view.post).toBeDefined();
207 let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
208 expect(deletedPost.post_view.post.deleted).toBe(true);
209 expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
211 // Make sure lemmy beta sees post is deleted
212 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
213 // This will be undefined because of the tombstone
214 expect(betaPost).toBeUndefined();
217 let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
218 expect(undeletedPost.post_view.post.deleted).toBe(false);
220 // Make sure lemmy beta sees post is undeleted
221 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
222 expect(betaPost2.post.deleted).toBe(false);
223 assertPostFederation(betaPost2, undeletedPost.post_view);
225 // Make sure lemmy beta cannot delete the post
226 let deletedPostBeta = await deletePost(beta, true, betaPost2.post);
227 expect(deletedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
230 test('Remove a post from admin and community on different instance', async () => {
231 let postRes = await createPost(alpha, betaCommunity.community.id);
233 let removedPost = await removePost(alpha, true, postRes.post_view.post);
234 expect(removedPost.post_view.post.removed).toBe(true);
235 expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
237 // Make sure lemmy beta sees post is NOT removed
238 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
239 expect(betaPost.post.removed).toBe(false);
242 let undeletedPost = await removePost(alpha, false, postRes.post_view.post);
243 expect(undeletedPost.post_view.post.removed).toBe(false);
245 // Make sure lemmy beta sees post is undeleted
246 let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
247 expect(betaPost2.post.removed).toBe(false);
248 assertPostFederation(betaPost2, undeletedPost.post_view);
251 test('Remove a post from admin and community on same instance', async () => {
252 await followBeta(alpha);
253 let postRes = await createPost(alpha, betaCommunity.community.id);
254 expect(postRes.post_view.post).toBeDefined();
256 // Get the id for beta
257 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
258 let betaPost = searchBeta.posts[0];
259 expect(betaPost).toBeDefined();
261 // The beta admin removes it (the community lives on beta)
262 let removePostRes = await removePost(beta, true, betaPost.post);
263 expect(removePostRes.post_view.post.removed).toBe(true);
265 // Make sure lemmy alpha sees post is removed
266 let alphaPost = await getPost(alpha, postRes.post_view.post.id);
267 // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
268 // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
271 let undeletedPost = await removePost(beta, false, betaPost.post);
272 expect(undeletedPost.post_view.post.removed).toBe(false);
274 // Make sure lemmy alpha sees post is undeleted
275 let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
276 expect(alphaPost2.post_view.post.removed).toBe(false);
277 assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
278 await unfollowRemotes(alpha);
281 test('Search for a post', async () => {
282 await unfollowRemotes(alpha);
283 let postRes = await createPost(alpha, betaCommunity.community.id);
284 expect(postRes.post_view.post).toBeDefined();
286 let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
288 expect(betaPost.post.name).toBeDefined();
291 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
292 let postRes = await createPost(alpha, betaCommunity.community.id);
293 expect(postRes.post_view.post).toBeDefined();
295 let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
296 expect(betaPost.post.name).toBeDefined();
299 test('Enforce site ban for federated user', async () => {
300 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
301 let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
302 expect(alphaPerson).toBeDefined();
304 // ban alpha from beta site
305 let banAlpha = await banPersonFromSite(beta, alphaPerson.person.id, true);
306 expect(banAlpha.banned).toBe(true);
308 // Alpha makes post on beta
309 let postRes = await createPost(alpha, betaCommunity.community.id);
310 expect(postRes.post_view.post).toBeDefined();
311 expect(postRes.post_view.community.local).toBe(false);
312 expect(postRes.post_view.creator.local).toBe(true);
313 expect(postRes.post_view.counts.score).toBe(1);
315 // Make sure that post doesn't make it to beta
316 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
317 let betaPost = searchBeta.posts[0];
318 expect(betaPost).toBeUndefined();
321 let unBanAlpha = await banPersonFromSite(beta, alphaPerson.person.id, false);
322 expect(unBanAlpha.banned).toBe(false);
325 test('Enforce community ban for federated user', async () => {
326 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
327 let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
328 expect(alphaPerson).toBeDefined();
330 // ban alpha from beta site
331 await banPersonFromCommunity(beta, alphaPerson.person.id, 2, false);
332 let banAlpha = await banPersonFromCommunity(beta, alphaPerson.person.id, 2, true);
333 expect(banAlpha.banned).toBe(true);
335 // Alpha tries to make post on beta, but it fails because of ban
336 let postRes = await createPost(alpha, betaCommunity.community.id);
337 expect(postRes.post_view).toBeUndefined();
340 let unBanAlpha = await banPersonFromCommunity(
342 alphaPerson.person.id,
346 expect(unBanAlpha.banned).toBe(false);
347 let postRes2 = await createPost(alpha, betaCommunity.community.id);
348 expect(postRes2.post_view.post).toBeDefined();
349 expect(postRes2.post_view.community.local).toBe(false);
350 expect(postRes2.post_view.creator.local).toBe(true);
351 expect(postRes2.post_view.counts.score).toBe(1);
353 // Make sure that post makes it to beta community
354 let searchBeta = await searchPostLocal(beta, postRes2.post_view.post);
355 let betaPost = searchBeta.posts[0];
356 expect(betaPost).toBeDefined();
359 test('Report a post', async () => {
360 let betaCommunity = (await resolveBetaCommunity(beta)).community;
361 let postRes = await createPost(beta, betaCommunity.community.id);
362 expect(postRes.post_view.post).toBeDefined();
364 let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
365 let alphaReport = (await reportPost(alpha, alphaPost.post.id, randomString(10)))
366 .post_report_view.post_report;
368 let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
369 expect(betaReport).toBeDefined();
370 expect(betaReport.resolved).toBe(false);
371 expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
372 expect(betaReport.original_post_url).toBe(alphaReport.original_post_url);
373 expect(betaReport.original_post_body).toBe(alphaReport.original_post_body);
374 expect(betaReport.reason).toBe(alphaReport.reason);