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