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