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