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   let gammaTrySticky = await stickyPost(gamma, true, gammaPost);
 177   let searchBeta3 = await searchPost(beta, postRes.post);
 178   let betaPost3 = searchBeta3.posts[0];
 179   expect(gammaTrySticky.post.stickied).toBe(true);
 180   expect(betaPost3.stickied).toBe(false);
 181 });
 182
 183 test('Lock a post', async () => {
 184   let search = await searchForBetaCommunity(alpha);
 185   await delay();
 186   let postRes = await createPost(alpha, search.communities[0].id);
 187
 188   // Lock the post
 189   let lockedPostRes = await lockPost(alpha, true, postRes.post);
 190   expect(lockedPostRes.post.locked).toBe(true);
 191   await delay();
 192
 193   // Make sure that post is locked on beta
 194   let searchBeta = await searchPostLocal(beta, postRes.post);
 195   let betaPost1 = searchBeta.posts[0];
 196   expect(betaPost1.locked).toBe(true);
 197
 198   // Try to make a new comment there, on alpha
 199   let comment = await createComment(alpha, postRes.post.id);
 200   expect(comment['error']).toBe('locked');
 201
 202   // Unlock a post
 203   let unlockedPost = await lockPost(alpha, false, postRes.post);
 204   expect(unlockedPost.post.locked).toBe(false);
 205
 206   // Make sure that post is unlocked on beta
 207   let searchBeta2 = await searchPost(beta, postRes.post);
 208   let betaPost2 = searchBeta2.posts[0];
 209   expect(betaPost2.community_local).toBe(true);
 210   expect(betaPost2.creator_local).toBe(false);
 211   expect(betaPost2.locked).toBe(false);
 212   await delay();
 213
 214   // Try to create a new comment, on beta
 215   let commentBeta = await createComment(beta, betaPost2.id);
 216   expect(commentBeta).toBeDefined();
 217 });
 218
 219 test('Delete a post', async () => {
 220   let search = await searchForBetaCommunity(alpha);
 221   let postRes = await createPost(alpha, search.communities[0].id);
 222
 223   let deletedPost = await deletePost(alpha, true, postRes.post);
 224   expect(deletedPost.post.deleted).toBe(true);
 225
 226   // Make sure lemmy beta sees post is deleted
 227   let searchBeta = await searchPost(beta, postRes.post);
 228   let betaPost = searchBeta.posts[0];
 229   // This will be undefined because of the tombstone
 230   expect(betaPost).toBeUndefined();
 231
 232   // Undelete
 233   let undeletedPost = await deletePost(alpha, false, postRes.post);
 234   expect(undeletedPost.post.deleted).toBe(false);
 235
 236   // Make sure lemmy beta sees post is undeleted
 237   let searchBeta2 = await searchPost(beta, postRes.post);
 238   let betaPost2 = searchBeta2.posts[0];
 239   expect(betaPost2.deleted).toBe(false);
 240   assertPostFederation(betaPost2, undeletedPost.post);
 241
 242   // Make sure lemmy beta cannot delete the post
 243   let deletedPostBeta = await deletePost(beta, true, betaPost2);
 244   expect(deletedPostBeta).toStrictEqual({ error: 'no_post_edit_allowed' });
 245 });
 246
 247 test('Remove a post from admin and community on different instance', async () => {
 248   let search = await searchForBetaCommunity(alpha);
 249   let postRes = await createPost(alpha, search.communities[0].id);
 250
 251   let removedPost = await removePost(alpha, true, postRes.post);
 252   expect(removedPost.post.removed).toBe(true);
 253   await delay();
 254
 255   // Make sure lemmy beta sees post is NOT removed
 256   let searchBeta = await searchPost(beta, postRes.post);
 257   let betaPost = searchBeta.posts[0];
 258   expect(betaPost.removed).toBe(false);
 259   await delay();
 260
 261   // Undelete
 262   let undeletedPost = await removePost(alpha, false, postRes.post);
 263   expect(undeletedPost.post.removed).toBe(false);
 264
 265   // Make sure lemmy beta sees post is undeleted
 266   let searchBeta2 = await searchPost(beta, postRes.post);
 267   let betaPost2 = searchBeta2.posts[0];
 268   expect(betaPost2.removed).toBe(false);
 269   assertPostFederation(betaPost2, undeletedPost.post);
 270 });
 271
 272 test('Remove a post from admin and community on same instance', async () => {
 273   let search = await searchForBetaCommunity(alpha);
 274   let postRes = await createPost(alpha, search.communities[0].id);
 275   await delay();
 276
 277   // Get the id for beta
 278   let searchBeta = await searchPost(beta, postRes.post);
 279   let betaPost = searchBeta.posts[0];
 280   await delay();
 281
 282   // The beta admin removes it (the community lives on beta)
 283   let removePostRes = await removePost(beta, true, betaPost);
 284   expect(removePostRes.post.removed).toBe(true);
 285   await delay();
 286
 287   // Make sure lemmy alpha sees post is removed
 288   let alphaPost = await getPost(alpha, postRes.post.id);
 289   expect(alphaPost.post.removed).toBe(true);
 290   assertPostFederation(alphaPost.post, removePostRes.post);
 291   await delay();
 292
 293   // Undelete
 294   let undeletedPost = await removePost(beta, false, betaPost);
 295   expect(undeletedPost.post.removed).toBe(false);
 296   await delay();
 297
 298   // Make sure lemmy alpha sees post is undeleted
 299   let alphaPost2 = await getPost(alpha, postRes.post.id);
 300   expect(alphaPost2.post.removed).toBe(false);
 301   assertPostFederation(alphaPost2.post, undeletedPost.post);
 302 });
 303
 304 test('Search for a post', async () => {
 305   let search = await searchForBetaCommunity(alpha);
 306   await delay();
 307   let postRes = await createPost(alpha, search.communities[0].id);
 308   await delay();
 309   let searchBeta = await searchPost(beta, postRes.post);
 310
 311   expect(searchBeta.posts[0].name).toBeDefined();
 312 });
 313
 314 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
 315   let search = await searchForBetaCommunity(alpha);
 316   let postRes = await createPost(alpha, search.communities[0].id);
 317   await delay();
 318
 319   let search2 = await searchPost(gamma, postRes.post);
 320   expect(search2.posts[0].name).toBeDefined();
 321 });
 322
 323 test('Enforce site ban for federated user', async () => {
 324
 325   let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
 326   let userSearch = await searchForUser(beta, alphaShortname);
 327   let alphaUser = userSearch.users[0];
 328   expect(alphaUser).toBeDefined();
 329   await delay();
 330
 331   // ban alpha from beta site
 332   let banAlpha = await banUserFromSite(beta, alphaUser.id, true);
 333   expect(banAlpha.banned).toBe(true);
 334   await delay();
 335
 336   // Alpha makes post on beta
 337   let search = await searchForBetaCommunity(alpha);
 338   await delay();
 339   let postRes = await createPost(alpha, search.communities[0].id);
 340   expect(postRes.post).toBeDefined();
 341   expect(postRes.post.community_local).toBe(false);
 342   expect(postRes.post.creator_local).toBe(true);
 343   expect(postRes.post.score).toBe(1);
 344   await delay();
 345
 346   // Make sure that post doesn't make it to beta
 347   let searchBeta = await searchPostLocal(beta, postRes.post);
 348   let betaPost = searchBeta.posts[0];
 349   expect(betaPost).toBeUndefined();
 350   await delay();
 351
 352   // Unban alpha
 353   let unBanAlpha = await banUserFromSite(beta, alphaUser.id, false);
 354   expect(unBanAlpha.banned).toBe(false);
 355 });
 356
 357 test('Enforce community ban for federated user', async () => {
 358   let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
 359   let userSearch = await searchForUser(beta, alphaShortname);
 360   let alphaUser = userSearch.users[0];
 361   expect(alphaUser).toBeDefined();
 362   await delay();
 363
 364   // ban alpha from beta site
 365   await banUserFromCommunity(beta, alphaUser.id, 2, false);
 366   let banAlpha = await banUserFromCommunity(beta, alphaUser.id, 2, true);
 367   expect(banAlpha.banned).toBe(true);
 368   await delay();
 369
 370   // Alpha makes post on beta
 371   let search = await searchForBetaCommunity(alpha);
 372   await delay();
 373   let postRes = await createPost(alpha, search.communities[0].id);
 374   expect(postRes.post).toBeDefined();
 375   expect(postRes.post.community_local).toBe(false);
 376   expect(postRes.post.creator_local).toBe(true);
 377   expect(postRes.post.score).toBe(1);
 378   await delay();
 379
 380   // Make sure that post doesn't make it to beta community
 381   let searchBeta = await searchPostLocal(beta, postRes.post);
 382   let betaPost = searchBeta.posts[0];
 383   expect(betaPost).toBeUndefined();
 384
 385   // Unban alpha
 386   let unBanAlpha = await banUserFromCommunity(beta, alphaUser.id, 2, false);
 387   expect(unBanAlpha.banned).toBe(false);
 388 });