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