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