api_tests/src/post.spec.ts

   1 jest.setTimeout(120000);
   2 import {
   3   alpha,
   4   beta,
   5   gamma,
   6   delta,
   7   epsilon,
   8   setupLogins,
   9   createPost,
  10   editPost,
  11   stickyPost,
  12   lockPost,
  13   resolvePost,
  14   likePost,
  15   followBeta,
  16   resolveBetaCommunity,
  17   createComment,
  18   deletePost,
  19   removePost,
  20   getPost,
  21   unfollowRemotes,
  22   resolvePerson,
  23   banPersonFromSite,
  24   searchPostLocal,
  25   followCommunity,
  26   banPersonFromCommunity,
  27   reportPost,
  28   listPostReports,
  29   randomString,
  30   registerUser,
  31   API,
  32   getSite
  33 } from './shared';
  34 import { PostView, CommunityView } from 'lemmy-js-client';
  35
  36 let betaCommunity: CommunityView;
  37
  38 beforeAll(async () => {
  39   await setupLogins();
  40   betaCommunity = (await resolveBetaCommunity(alpha)).community;
  41   expect(betaCommunity).toBeDefined();
  42   await unfollows();
  43 });
  44
  45 afterAll(async () => {
  46   await unfollows();
  47 });
  48
  49 async function unfollows() {
  50   await unfollowRemotes(alpha);
  51   await unfollowRemotes(gamma);
  52   await unfollowRemotes(delta);
  53   await unfollowRemotes(epsilon);
  54 }
  55
  56 function assertPostFederation(postOne: PostView, postTwo: PostView) {
  57   expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
  58   expect(postOne.post.name).toBe(postTwo.post.name);
  59   expect(postOne.post.body).toBe(postTwo.post.body);
  60   expect(postOne.post.url).toBe(postTwo.post.url);
  61   expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
  62   expect(postOne.post.embed_title).toBe(postTwo.post.embed_title);
  63   expect(postOne.post.embed_description).toBe(postTwo.post.embed_description);
  64   expect(postOne.post.embed_html).toBe(postTwo.post.embed_html);
  65   expect(postOne.post.published).toBe(postTwo.post.published);
  66   expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
  67   expect(postOne.post.locked).toBe(postTwo.post.locked);
  68   expect(postOne.post.removed).toBe(postTwo.post.removed);
  69   expect(postOne.post.deleted).toBe(postTwo.post.deleted);
  70 }
  71
  72 test('Create a post', async () => {
  73   let postRes = await createPost(alpha, betaCommunity.community.id);
  74   expect(postRes.post_view.post).toBeDefined();
  75   expect(postRes.post_view.community.local).toBe(false);
  76   expect(postRes.post_view.creator.local).toBe(true);
  77   expect(postRes.post_view.counts.score).toBe(1);
  78
  79   // Make sure that post is liked on beta
  80   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
  81
  82   expect(betaPost).toBeDefined();
  83   expect(betaPost.community.local).toBe(true);
  84   expect(betaPost.creator.local).toBe(false);
  85   expect(betaPost.counts.score).toBe(1);
  86   assertPostFederation(betaPost, postRes.post_view);
  87
  88   // Delta only follows beta, so it should not see an alpha ap_id
  89   let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
  90   expect(deltaPost).toBeUndefined();
  91
  92   // Epsilon has alpha blocked, it should not see the alpha post
  93   let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
  94   expect(epsilonPost).toBeUndefined();
  95 });
  96
  97 test('Create a post in a non-existent community', async () => {
  98   let postRes = await createPost(alpha, -2);
  99   expect(postRes).toStrictEqual({ error: 'couldnt_find_community' });
 100 });
 101
 102 test('Unlike a post', async () => {
 103   let postRes = await createPost(alpha, betaCommunity.community.id);
 104   let unlike = await likePost(alpha, 0, postRes.post_view.post);
 105   expect(unlike.post_view.counts.score).toBe(0);
 106
 107   // Try to unlike it again, make sure it stays at 0
 108   let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
 109   expect(unlike2.post_view.counts.score).toBe(0);
 110
 111   // Make sure that post is unliked on beta
 112   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
 113   expect(betaPost).toBeDefined();
 114   expect(betaPost.community.local).toBe(true);
 115   expect(betaPost.creator.local).toBe(false);
 116   expect(betaPost.counts.score).toBe(0);
 117   assertPostFederation(betaPost, postRes.post_view);
 118 });
 119
 120 test('Update a post', async () => {
 121   let postRes = await createPost(alpha, betaCommunity.community.id);
 122
 123   let updatedName = 'A jest test federated post, updated';
 124   let updatedPost = await editPost(alpha, postRes.post_view.post);
 125   expect(updatedPost.post_view.post.name).toBe(updatedName);
 126   expect(updatedPost.post_view.community.local).toBe(false);
 127   expect(updatedPost.post_view.creator.local).toBe(true);
 128
 129   // Make sure that post is updated on beta
 130   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
 131   expect(betaPost.community.local).toBe(true);
 132   expect(betaPost.creator.local).toBe(false);
 133   expect(betaPost.post.name).toBe(updatedName);
 134   assertPostFederation(betaPost, updatedPost.post_view);
 135
 136   // Make sure lemmy beta cannot update the post
 137   let updatedPostBeta = await editPost(beta, betaPost.post);
 138   expect(updatedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
 139 });
 140
 141 test('Sticky a post', async () => {
 142   let postRes = await createPost(alpha, betaCommunity.community.id);
 143
 144   let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
 145   let stickiedPostRes = await stickyPost(beta, true, betaPost1.post);
 146   expect(stickiedPostRes.post_view.post.stickied).toBe(true);
 147
 148   // Make sure that post is stickied on beta
 149   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
 150   expect(betaPost.community.local).toBe(true);
 151   expect(betaPost.creator.local).toBe(false);
 152   expect(betaPost.post.stickied).toBe(true);
 153
 154   // Unsticky a post
 155   let unstickiedPost = await stickyPost(beta, false, betaPost1.post);
 156   expect(unstickiedPost.post_view.post.stickied).toBe(false);
 157
 158   // Make sure that post is unstickied on beta
 159   let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
 160   expect(betaPost2.community.local).toBe(true);
 161   expect(betaPost2.creator.local).toBe(false);
 162   expect(betaPost2.post.stickied).toBe(false);
 163
 164   // Make sure that gamma cannot sticky the post on beta
 165   let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
 166   let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
 167   let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post;
 168   expect(gammaTrySticky.post_view.post.stickied).toBe(true);
 169   expect(betaPost3.post.stickied).toBe(false);
 170 });
 171
 172 test('Lock a post', async () => {
 173   await followCommunity(alpha, true, betaCommunity.community.id);
 174   let postRes = await createPost(alpha, betaCommunity.community.id);
 175
 176   // Lock the post
 177   let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post;
 178   let lockedPostRes = await lockPost(beta, true, betaPost1.post);
 179   expect(lockedPostRes.post_view.post.locked).toBe(true);
 180
 181   // Make sure that post is locked on alpha
 182   let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
 183   let alphaPost1 = searchAlpha.posts[0];
 184   expect(alphaPost1.post.locked).toBe(true);
 185
 186   // Try to make a new comment there, on alpha
 187   let comment: any = await createComment(alpha, alphaPost1.post.id);
 188   expect(comment['error']).toBe('locked');
 189
 190   // Unlock a post
 191   let unlockedPost = await lockPost(beta, false, betaPost1.post);
 192   expect(unlockedPost.post_view.post.locked).toBe(false);
 193
 194   // Make sure that post is unlocked on alpha
 195   let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
 196   let alphaPost2 = searchAlpha2.posts[0];
 197   expect(alphaPost2.community.local).toBe(false);
 198   expect(alphaPost2.creator.local).toBe(true);
 199   expect(alphaPost2.post.locked).toBe(false);
 200
 201   // Try to create a new comment, on alpha
 202   let commentAlpha = await createComment(alpha, alphaPost1.post.id);
 203   expect(commentAlpha).toBeDefined();
 204 });
 205
 206 test('Delete a post', async () => {
 207   let postRes = await createPost(alpha, betaCommunity.community.id);
 208   expect(postRes.post_view.post).toBeDefined();
 209
 210   let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
 211   expect(deletedPost.post_view.post.deleted).toBe(true);
 212   expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
 213
 214   // Make sure lemmy beta sees post is deleted
 215   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
 216   // This will be undefined because of the tombstone
 217   expect(betaPost).toBeUndefined();
 218
 219   // Undelete
 220   let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
 221   expect(undeletedPost.post_view.post.deleted).toBe(false);
 222
 223   // Make sure lemmy beta sees post is undeleted
 224   let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
 225   expect(betaPost2.post.deleted).toBe(false);
 226   assertPostFederation(betaPost2, undeletedPost.post_view);
 227
 228   // Make sure lemmy beta cannot delete the post
 229   let deletedPostBeta = await deletePost(beta, true, betaPost2.post);
 230   expect(deletedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
 231 });
 232
 233 test('Remove a post from admin and community on different instance', async () => {
 234   let postRes = await createPost(alpha, betaCommunity.community.id);
 235
 236   let removedPost = await removePost(alpha, true, postRes.post_view.post);
 237   expect(removedPost.post_view.post.removed).toBe(true);
 238   expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
 239
 240   // Make sure lemmy beta sees post is NOT removed
 241   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
 242   expect(betaPost.post.removed).toBe(false);
 243
 244   // Undelete
 245   let undeletedPost = await removePost(alpha, false, postRes.post_view.post);
 246   expect(undeletedPost.post_view.post.removed).toBe(false);
 247
 248   // Make sure lemmy beta sees post is undeleted
 249   let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post;
 250   expect(betaPost2.post.removed).toBe(false);
 251   assertPostFederation(betaPost2, undeletedPost.post_view);
 252 });
 253
 254 test('Remove a post from admin and community on same instance', async () => {
 255   await followBeta(alpha);
 256   let postRes = await createPost(alpha, betaCommunity.community.id);
 257   expect(postRes.post_view.post).toBeDefined();
 258
 259   // Get the id for beta
 260   let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
 261   let betaPost = searchBeta.posts[0];
 262   expect(betaPost).toBeDefined();
 263
 264   // The beta admin removes it (the community lives on beta)
 265   let removePostRes = await removePost(beta, true, betaPost.post);
 266   expect(removePostRes.post_view.post.removed).toBe(true);
 267
 268   // Make sure lemmy alpha sees post is removed
 269   let alphaPost = await getPost(alpha, postRes.post_view.post.id);
 270   // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
 271   // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
 272
 273   // Undelete
 274   let undeletedPost = await removePost(beta, false, betaPost.post);
 275   expect(undeletedPost.post_view.post.removed).toBe(false);
 276
 277   // Make sure lemmy alpha sees post is undeleted
 278   let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
 279   expect(alphaPost2.post_view.post.removed).toBe(false);
 280   assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
 281   await unfollowRemotes(alpha);
 282 });
 283
 284 test('Search for a post', async () => {
 285   await unfollowRemotes(alpha);
 286   let postRes = await createPost(alpha, betaCommunity.community.id);
 287   expect(postRes.post_view.post).toBeDefined();
 288
 289   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
 290
 291   expect(betaPost.post.name).toBeDefined();
 292 });
 293
 294 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
 295   let postRes = await createPost(alpha, betaCommunity.community.id);
 296   expect(postRes.post_view.post).toBeDefined();
 297
 298   let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post;
 299   expect(betaPost.post.name).toBeDefined();
 300 });
 301
 302 test('Enforce site ban for federated user', async () => {
 303   // create a test user
 304   let alphaUserJwt = await registerUser(alpha);
 305   expect(alphaUserJwt).toBeDefined();
 306   let alphaUser: API = {
 307       client: alpha.client,
 308       auth: alphaUserJwt.jwt,
 309   };
 310   let alphaUserActorId = (await getSite(alphaUser)).my_user.local_user_view.person.actor_id;
 311   expect(alphaUserActorId).toBeDefined();
 312   let alphaPerson = (await resolvePerson(alphaUser, alphaUserActorId)).person;
 313   expect(alphaPerson).toBeDefined();
 314
 315   // alpha makes post in beta community, it federates to beta instance
 316   let postRes1 = await createPost(alphaUser, betaCommunity.community.id);
 317   let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
 318   expect(searchBeta1.posts[0]).toBeDefined();
 319
 320   // ban alpha from its instance
 321   let banAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, true, true);
 322   expect(banAlpha.banned).toBe(true);
 323
 324   // alpha ban should be federated to beta
 325   let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
 326   expect(alphaUserOnBeta1.person.person.banned).toBe(true);
 327
 328   // existing alpha post should be removed on beta
 329   let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
 330   expect(searchBeta2.posts[0]).toBeUndefined();
 331
 332   // Unban alpha
 333   let unBanAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, false, false);
 334   expect(unBanAlpha.banned).toBe(false);
 335
 336   // alpha makes new post in beta community, it federates
 337   let postRes2 = await createPost(alphaUser, betaCommunity.community.id);
 338   let searchBeta3 = await searchPostLocal(beta, postRes2.post_view.post);
 339   expect(searchBeta3.posts[0]).toBeDefined();
 340
 341   let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId)
 342   expect(alphaUserOnBeta2.person.person.banned).toBe(false);
 343 });
 344
 345 test('Enforce community ban for federated user', async () => {
 346   let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
 347   let alphaPerson = (await resolvePerson(beta, alphaShortname)).person;
 348   expect(alphaPerson).toBeDefined();
 349
 350   // make a post in beta, it goes through
 351   let postRes1 = await createPost(alpha, betaCommunity.community.id);
 352   let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
 353   expect(searchBeta1.posts[0]).toBeDefined();
 354
 355   // ban alpha from beta community
 356   let banAlpha = await banPersonFromCommunity(beta, alphaPerson.person.id, 2, true, true);
 357   expect(banAlpha.banned).toBe(true);
 358
 359   // ensure that the post by alpha got removed
 360   let searchAlpha1 = await searchPostLocal(alpha, postRes1.post_view.post);
 361   expect(searchAlpha1.posts[0]).toBeUndefined();
 362
 363   // Alpha tries to make post on beta, but it fails because of ban
 364   let postRes2 = await createPost(alpha, betaCommunity.community.id);
 365   expect(postRes2.post_view).toBeUndefined();
 366
 367   // Unban alpha
 368   let unBanAlpha = await banPersonFromCommunity(
 369     beta,
 370     alphaPerson.person.id,
 371     2,
 372     false,
 373     false
 374   );
 375   expect(unBanAlpha.banned).toBe(false);
 376   let postRes3 = await createPost(alpha, betaCommunity.community.id);
 377   expect(postRes3.post_view.post).toBeDefined();
 378   expect(postRes3.post_view.community.local).toBe(false);
 379   expect(postRes3.post_view.creator.local).toBe(true);
 380   expect(postRes3.post_view.counts.score).toBe(1);
 381
 382   // Make sure that post makes it to beta community
 383   let searchBeta2 = await searchPostLocal(beta, postRes3.post_view.post);
 384   expect(searchBeta2.posts[0]).toBeDefined();
 385 });
 386
 387 test('Report a post', async () => {
 388   let betaCommunity = (await resolveBetaCommunity(beta)).community;
 389   let postRes = await createPost(beta, betaCommunity.community.id);
 390   expect(postRes.post_view.post).toBeDefined();
 391
 392   let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post;
 393   let alphaReport = (await reportPost(alpha, alphaPost.post.id, randomString(10)))
 394         .post_report_view.post_report;
 395
 396   let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
 397   expect(betaReport).toBeDefined();
 398   expect(betaReport.resolved).toBe(false);
 399   expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
 400   expect(betaReport.original_post_url).toBe(alphaReport.original_post_url);
 401   expect(betaReport.original_post_body).toBe(alphaReport.original_post_body);
 402   expect(betaReport.reason).toBe(alphaReport.reason);
 403 });