1 jest.setTimeout(120000);
16 searchForBetaCommunity,
27 import { PostView, CommunityView } from 'lemmy-js-client';
29 let betaCommunity: CommunityView;
31 beforeAll(async () => {
33 let search = await searchForBetaCommunity(alpha);
34 betaCommunity = search.communities[0];
38 afterAll(async () => {
42 async function unfollows() {
43 await unfollowRemotes(alpha);
44 await unfollowRemotes(gamma);
45 await unfollowRemotes(delta);
46 await unfollowRemotes(epsilon);
49 function assertPostFederation(postOne: PostView, postTwo: PostView) {
50 expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
51 expect(postOne.post.name).toBe(postTwo.post.name);
52 expect(postOne.post.body).toBe(postTwo.post.body);
53 expect(postOne.post.url).toBe(postTwo.post.url);
54 expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
55 expect(postOne.post.embed_title).toBe(postTwo.post.embed_title);
56 expect(postOne.post.embed_description).toBe(postTwo.post.embed_description);
57 expect(postOne.post.embed_html).toBe(postTwo.post.embed_html);
58 expect(postOne.post.published).toBe(postTwo.post.published);
59 expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
60 expect(postOne.post.locked).toBe(postTwo.post.locked);
61 expect(postOne.post.removed).toBe(postTwo.post.removed);
62 expect(postOne.post.deleted).toBe(postTwo.post.deleted);
65 test('Create a post', async () => {
66 let postRes = await createPost(alpha, betaCommunity.community.id);
67 expect(postRes.post_view.post).toBeDefined();
68 expect(postRes.post_view.community.local).toBe(false);
69 expect(postRes.post_view.creator.local).toBe(true);
70 expect(postRes.post_view.counts.score).toBe(1);
72 // Make sure that post is liked on beta
73 let searchBeta = await searchPost(beta, postRes.post_view.post);
74 let betaPost = searchBeta.posts[0];
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 searchDelta = await searchPost(delta, postRes.post_view.post);
84 expect(searchDelta.posts[0]).toBeUndefined();
86 // Epsilon has alpha blocked, it should not see the alpha post
87 let searchEpsilon = await searchPost(epsilon, postRes.post_view.post);
88 expect(searchEpsilon.posts[0]).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_create_post' });
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 searchBeta = await searchPost(beta, postRes.post_view.post);
107 let betaPost = searchBeta.posts[0];
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 searchBeta = await searchPost(beta, postRes.post_view.post);
126 let betaPost = searchBeta.posts[0];
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);
134 expect(updatedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
137 test('Sticky a post', async () => {
138 let postRes = await createPost(alpha, betaCommunity.community.id);
140 let stickiedPostRes = await stickyPost(alpha, true, postRes.post_view.post);
141 expect(stickiedPostRes.post_view.post.stickied).toBe(true);
143 // Make sure that post is stickied on beta
144 let searchBeta = await searchPost(beta, postRes.post_view.post);
145 let betaPost = searchBeta.posts[0];
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(alpha, false, postRes.post_view.post);
152 expect(unstickiedPost.post_view.post.stickied).toBe(false);
154 // Make sure that post is unstickied on beta
155 let searchBeta2 = await searchPost(beta, postRes.post_view.post);
156 let betaPost2 = searchBeta2.posts[0];
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 searchGamma = await searchPost(gamma, postRes.post_view.post);
163 let gammaPost = searchGamma.posts[0];
164 let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
165 let searchBeta3 = await searchPost(beta, postRes.post_view.post);
166 let betaPost3 = searchBeta3.posts[0];
167 expect(gammaTrySticky.post_view.post.stickied).toBe(true);
168 expect(betaPost3.post.stickied).toBe(false);
171 test('Lock a post', async () => {
172 let postRes = await createPost(alpha, betaCommunity.community.id);
175 let lockedPostRes = await lockPost(alpha, true, postRes.post_view.post);
176 expect(lockedPostRes.post_view.post.locked).toBe(true);
178 // Make sure that post is locked on beta
179 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
180 let betaPost1 = searchBeta.posts[0];
181 expect(betaPost1.post.locked).toBe(true);
183 // Try to make a new comment there, on alpha
184 let comment: any = await createComment(alpha, postRes.post_view.post.id);
185 expect(comment['error']).toBe('locked');
188 let unlockedPost = await lockPost(alpha, false, postRes.post_view.post);
189 expect(unlockedPost.post_view.post.locked).toBe(false);
191 // Make sure that post is unlocked on beta
192 let searchBeta2 = await searchPost(beta, postRes.post_view.post);
193 let betaPost2 = searchBeta2.posts[0];
194 expect(betaPost2.community.local).toBe(true);
195 expect(betaPost2.creator.local).toBe(false);
196 expect(betaPost2.post.locked).toBe(false);
198 // Try to create a new comment, on beta
199 let commentBeta = await createComment(beta, betaPost2.post.id);
200 expect(commentBeta).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);
210 // Make sure lemmy beta sees post is deleted
211 let searchBeta = await searchPost(beta, postRes.post_view.post);
212 let betaPost = searchBeta.posts[0];
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 searchBeta2 = await searchPost(beta, postRes.post_view.post);
222 let betaPost2 = searchBeta2.posts[0];
223 expect(betaPost2.post.deleted).toBe(false);
224 assertPostFederation(betaPost2, undeletedPost.post_view);
226 // Make sure lemmy beta cannot delete the post
227 let deletedPostBeta = await deletePost(beta, true, betaPost2.post);
228 expect(deletedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
231 test('Remove a post from admin and community on different instance', async () => {
232 let postRes = await createPost(alpha, betaCommunity.community.id);
234 let removedPost = await removePost(alpha, true, postRes.post_view.post);
235 expect(removedPost.post_view.post.removed).toBe(true);
237 // Make sure lemmy beta sees post is NOT removed
238 let searchBeta = await searchPost(beta, postRes.post_view.post);
239 let betaPost = searchBeta.posts[0];
240 expect(betaPost.post.removed).toBe(false);
243 let undeletedPost = await removePost(alpha, false, postRes.post_view.post);
244 expect(undeletedPost.post_view.post.removed).toBe(false);
246 // Make sure lemmy beta sees post is undeleted
247 let searchBeta2 = await searchPost(beta, postRes.post_view.post);
248 let betaPost2 = searchBeta2.posts[0];
249 expect(betaPost2.post.removed).toBe(false);
250 assertPostFederation(betaPost2, undeletedPost.post_view);
253 test('Remove a post from admin and community on same instance', async () => {
254 await followBeta(alpha);
255 let postRes = await createPost(alpha, betaCommunity.community.id);
256 expect(postRes.post_view.post).toBeDefined();
258 // Get the id for beta
259 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
260 let betaPost = searchBeta.posts[0];
261 expect(betaPost).toBeDefined();
263 // The beta admin removes it (the community lives on beta)
264 let removePostRes = await removePost(beta, true, betaPost.post);
265 expect(removePostRes.post_view.post.removed).toBe(true);
267 // Make sure lemmy alpha sees post is removed
268 let alphaPost = await getPost(alpha, postRes.post_view.post.id);
269 // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
270 // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
273 let undeletedPost = await removePost(beta, false, betaPost.post);
274 expect(undeletedPost.post_view.post.removed).toBe(false);
276 // Make sure lemmy alpha sees post is undeleted
277 let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
278 expect(alphaPost2.post_view.post.removed).toBe(false);
279 assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
280 await unfollowRemotes(alpha);
283 test('Search for a post', async () => {
284 await unfollowRemotes(alpha);
285 let postRes = await createPost(alpha, betaCommunity.community.id);
286 expect(postRes.post_view.post).toBeDefined();
288 let searchBeta = await searchPost(beta, postRes.post_view.post);
290 expect(searchBeta.posts[0].post.name).toBeDefined();
293 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
294 let postRes = await createPost(alpha, betaCommunity.community.id);
295 expect(postRes.post_view.post).toBeDefined();
297 let search2 = await searchPost(gamma, postRes.post_view.post);
298 expect(search2.posts[0].post.name).toBeDefined();
301 test('Enforce site ban for federated user', async () => {
302 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
303 let userSearch = await searchForUser(beta, alphaShortname);
304 let alphaUser = userSearch.users[0];
305 expect(alphaUser).toBeDefined();
307 // ban alpha from beta site
308 let banAlpha = await banUserFromSite(beta, alphaUser.user.id, true);
309 expect(banAlpha.banned).toBe(true);
311 // Alpha makes post on beta
312 let postRes = await createPost(alpha, betaCommunity.community.id);
313 expect(postRes.post_view.post).toBeDefined();
314 expect(postRes.post_view.community.local).toBe(false);
315 expect(postRes.post_view.creator.local).toBe(true);
316 expect(postRes.post_view.counts.score).toBe(1);
318 // Make sure that post doesn't make it to beta
319 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
320 let betaPost = searchBeta.posts[0];
321 expect(betaPost).toBeUndefined();
324 let unBanAlpha = await banUserFromSite(beta, alphaUser.user.id, false);
325 expect(unBanAlpha.banned).toBe(false);
328 test('Enforce community ban for federated user', async () => {
329 let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
330 let userSearch = await searchForUser(beta, alphaShortname);
331 let alphaUser = userSearch.users[0];
332 expect(alphaUser).toBeDefined();
334 // ban alpha from beta site
335 await banUserFromCommunity(beta, alphaUser.user.id, 2, false);
336 let banAlpha = await banUserFromCommunity(beta, alphaUser.user.id, 2, true);
337 expect(banAlpha.banned).toBe(true);
339 // Alpha makes post on beta
340 let postRes = await createPost(alpha, betaCommunity.community.id);
341 expect(postRes.post_view.post).toBeDefined();
342 expect(postRes.post_view.community.local).toBe(false);
343 expect(postRes.post_view.creator.local).toBe(true);
344 expect(postRes.post_view.counts.score).toBe(1);
346 // Make sure that post doesn't make it to beta community
347 let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
348 let betaPost = searchBeta.posts[0];
349 expect(betaPost).toBeUndefined();
352 let unBanAlpha = await banUserFromCommunity(
358 expect(unBanAlpha.banned).toBe(false);