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