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