api_tests/src/post.spec.ts

   1 jest.setTimeout(120000);
   2 import {None} from '@sniptt/monads';
   3 import { PostView, CommunityView } from 'lemmy-js-client';
   4 import {
   5   alpha,
   6   beta,
   7   gamma,
   8   delta,
   9   epsilon,
  10   setupLogins,
  11   createPost,
  12   editPost,
  13   stickyPost,
  14   lockPost,
  15   resolvePost,
  16   likePost,
  17   followBeta,
  18   resolveBetaCommunity,
  19   createComment,
  20   deletePost,
  21   removePost,
  22   getPost,
  23   unfollowRemotes,
  24   resolvePerson,
  25   banPersonFromSite,
  26   searchPostLocal,
  27   followCommunity,
  28   banPersonFromCommunity,
  29   reportPost,
  30   listPostReports,
  31   randomString,
  32   registerUser,
  33   API,
  34   getSite,
  35   unfollows,
  36   resolveCommunity
  37 } from './shared';
  38
  39 let betaCommunity: CommunityView;
  40
  41 beforeAll(async () => {
  42   await setupLogins();
  43   betaCommunity = (await resolveBetaCommunity(alpha)).community.unwrap();
  44   expect(betaCommunity).toBeDefined();
  45   await unfollows();
  46 });
  47
  48 afterAll(async () => {
  49   await unfollows();
  50 });
  51
  52 function assertPostFederation(postOne: PostView, postTwo: PostView) {
  53   expect(postOne.post.ap_id).toBe(postTwo.post.ap_id);
  54   expect(postOne.post.name).toBe(postTwo.post.name);
  55   expect(postOne.post.body.unwrapOr("none")).toBe(postTwo.post.body.unwrapOr("none"));
  56   expect(postOne.post.url.unwrapOr("none")).toBe(postTwo.post.url.unwrapOr("none"));
  57   expect(postOne.post.nsfw).toBe(postTwo.post.nsfw);
  58   expect(postOne.post.embed_title.unwrapOr("none")).toBe(postTwo.post.embed_title.unwrapOr("none"));
  59   expect(postOne.post.embed_description.unwrapOr("none")).toBe(postTwo.post.embed_description.unwrapOr("none"));
  60   expect(postOne.post.embed_html.unwrapOr("none")).toBe(postTwo.post.embed_html.unwrapOr("none"));
  61   expect(postOne.post.published).toBe(postTwo.post.published);
  62   expect(postOne.community.actor_id).toBe(postTwo.community.actor_id);
  63   expect(postOne.post.locked).toBe(postTwo.post.locked);
  64   expect(postOne.post.removed).toBe(postTwo.post.removed);
  65   expect(postOne.post.deleted).toBe(postTwo.post.deleted);
  66 }
  67
  68 test('Create a post', async () => {
  69   let postRes = await createPost(alpha, betaCommunity.community.id);
  70   expect(postRes.post_view.post).toBeDefined();
  71   expect(postRes.post_view.community.local).toBe(false);
  72   expect(postRes.post_view.creator.local).toBe(true);
  73   expect(postRes.post_view.counts.score).toBe(1);
  74
  75   // Make sure that post is liked on beta
  76   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
  77
  78   expect(betaPost).toBeDefined();
  79   expect(betaPost.community.local).toBe(true);
  80   expect(betaPost.creator.local).toBe(false);
  81   expect(betaPost.counts.score).toBe(1);
  82   assertPostFederation(betaPost, postRes.post_view);
  83
  84   // Delta only follows beta, so it should not see an alpha ap_id
  85   let deltaPost = (await resolvePost(delta, postRes.post_view.post)).post;
  86   expect(deltaPost.isNone()).toBe(true)
  87
  88   // Epsilon has alpha blocked, it should not see the alpha post
  89   let epsilonPost = (await resolvePost(epsilon, postRes.post_view.post)).post;
  90   expect(epsilonPost.isNone()).toBe(true);
  91 });
  92
  93 test('Create a post in a non-existent community', async () => {
  94   let postRes = await createPost(alpha, -2) as any;
  95   expect(postRes.error).toBe('couldnt_find_community');
  96 });
  97
  98 test('Unlike a post', async () => {
  99   let postRes = await createPost(alpha, betaCommunity.community.id);
 100   let unlike = await likePost(alpha, 0, postRes.post_view.post);
 101   expect(unlike.post_view.counts.score).toBe(0);
 102
 103   // Try to unlike it again, make sure it stays at 0
 104   let unlike2 = await likePost(alpha, 0, postRes.post_view.post);
 105   expect(unlike2.post_view.counts.score).toBe(0);
 106
 107   // Make sure that post is unliked on beta
 108   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 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 betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 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) as any;
 134   expect(updatedPostBeta.error).toBe('no_post_edit_allowed');
 135 });
 136
 137 test('Sticky a post', async () => {
 138   let postRes = await createPost(alpha, betaCommunity.community.id);
 139
 140   let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 141   let stickiedPostRes = await stickyPost(beta, true, betaPost1.post);
 142   expect(stickiedPostRes.post_view.post.stickied).toBe(true);
 143
 144   // Make sure that post is stickied on beta
 145   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 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(beta, false, betaPost1.post);
 152   expect(unstickiedPost.post_view.post.stickied).toBe(false);
 153
 154   // Make sure that post is unstickied on beta
 155   let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 156   expect(betaPost2.community.local).toBe(true);
 157   expect(betaPost2.creator.local).toBe(false);
 158   expect(betaPost2.post.stickied).toBe(false);
 159
 160   // Make sure that gamma cannot sticky the post on beta
 161   let gammaPost = (await resolvePost(gamma, postRes.post_view.post)).post.unwrap();
 162   let gammaTrySticky = await stickyPost(gamma, true, gammaPost.post);
 163   let betaPost3 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 164   expect(gammaTrySticky.post_view.post.stickied).toBe(true);
 165   expect(betaPost3.post.stickied).toBe(false);
 166 });
 167
 168 test('Lock a post', async () => {
 169   await followCommunity(alpha, true, betaCommunity.community.id);
 170   let postRes = await createPost(alpha, betaCommunity.community.id);
 171
 172   // Lock the post
 173   let betaPost1 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 174   let lockedPostRes = await lockPost(beta, true, betaPost1.post);
 175   expect(lockedPostRes.post_view.post.locked).toBe(true);
 176
 177   // Make sure that post is locked on alpha
 178   let searchAlpha = await searchPostLocal(alpha, postRes.post_view.post);
 179   let alphaPost1 = searchAlpha.posts[0];
 180   expect(alphaPost1.post.locked).toBe(true);
 181
 182   // Try to make a new comment there, on alpha
 183   let comment: any = await createComment(alpha, alphaPost1.post.id, None);
 184   expect(comment['error']).toBe('locked');
 185
 186   // Unlock a post
 187   let unlockedPost = await lockPost(beta, false, betaPost1.post);
 188   expect(unlockedPost.post_view.post.locked).toBe(false);
 189
 190   // Make sure that post is unlocked on alpha
 191   let searchAlpha2 = await searchPostLocal(alpha, postRes.post_view.post);
 192   let alphaPost2 = searchAlpha2.posts[0];
 193   expect(alphaPost2.community.local).toBe(false);
 194   expect(alphaPost2.creator.local).toBe(true);
 195   expect(alphaPost2.post.locked).toBe(false);
 196
 197   // Try to create a new comment, on alpha
 198   let commentAlpha = await createComment(alpha, alphaPost1.post.id, None);
 199   expect(commentAlpha).toBeDefined();
 200 });
 201
 202 test('Delete a post', async () => {
 203   let postRes = await createPost(alpha, betaCommunity.community.id);
 204   expect(postRes.post_view.post).toBeDefined();
 205
 206   let deletedPost = await deletePost(alpha, true, postRes.post_view.post);
 207   expect(deletedPost.post_view.post.deleted).toBe(true);
 208   expect(deletedPost.post_view.post.name).toBe(postRes.post_view.post.name);
 209
 210   // Make sure lemmy beta sees post is deleted
 211   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post;
 212   // This will be undefined because of the tombstone
 213   expect(betaPost.isNone()).toBe(true);
 214
 215   // Undelete
 216   let undeletedPost = await deletePost(alpha, false, postRes.post_view.post);
 217   expect(undeletedPost.post_view.post.deleted).toBe(false);
 218
 219   // Make sure lemmy beta sees post is undeleted
 220   let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 221   expect(betaPost2.post.deleted).toBe(false);
 222   assertPostFederation(betaPost2, undeletedPost.post_view);
 223
 224   // Make sure lemmy beta cannot delete the post
 225   let deletedPostBeta = await deletePost(beta, true, betaPost2.post) as any;
 226   expect(deletedPostBeta.error).toStrictEqual('no_post_edit_allowed');
 227 });
 228
 229 test('Remove a post from admin and community on different instance', async () => {
 230   let gammaCommunity = await resolveCommunity(gamma, betaCommunity.community.actor_id);
 231   let postRes = await createPost(gamma, gammaCommunity.community.unwrap().community.id);
 232
 233   let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post.unwrap();
 234   let removedPost = await removePost(alpha, true, alphaPost.post);
 235   expect(removedPost.post_view.post.removed).toBe(true);
 236   expect(removedPost.post_view.post.name).toBe(postRes.post_view.post.name);
 237
 238   // Make sure lemmy beta sees post is NOT removed
 239   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 240   expect(betaPost.post.removed).toBe(false);
 241
 242   // Undelete
 243   let undeletedPost = await removePost(alpha, false, alphaPost.post);
 244   expect(undeletedPost.post_view.post.removed).toBe(false);
 245
 246   // Make sure lemmy beta sees post is undeleted
 247   let betaPost2 = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 248   expect(betaPost2.post.removed).toBe(false);
 249   assertPostFederation(betaPost2, undeletedPost.post_view);
 250 });
 251
 252 test('Remove a post from admin and community on same instance', async () => {
 253   await followBeta(alpha);
 254   let postRes = await createPost(alpha, betaCommunity.community.id);
 255   expect(postRes.post_view.post).toBeDefined();
 256
 257   // Get the id for beta
 258   let searchBeta = await searchPostLocal(beta, postRes.post_view.post);
 259   let betaPost = searchBeta.posts[0];
 260   expect(betaPost).toBeDefined();
 261
 262   // The beta admin removes it (the community lives on beta)
 263   let removePostRes = await removePost(beta, true, betaPost.post);
 264   expect(removePostRes.post_view.post.removed).toBe(true);
 265
 266   // Make sure lemmy alpha sees post is removed
 267   // let alphaPost = await getPost(alpha, postRes.post_view.post.id);
 268   // expect(alphaPost.post_view.post.removed).toBe(true); // TODO this shouldn't be commented
 269   // assertPostFederation(alphaPost.post_view, removePostRes.post_view);
 270
 271   // Undelete
 272   let undeletedPost = await removePost(beta, false, betaPost.post);
 273   expect(undeletedPost.post_view.post.removed).toBe(false);
 274
 275   // Make sure lemmy alpha sees post is undeleted
 276   let alphaPost2 = await getPost(alpha, postRes.post_view.post.id);
 277   expect(alphaPost2.post_view.post.removed).toBe(false);
 278   assertPostFederation(alphaPost2.post_view, undeletedPost.post_view);
 279   await unfollowRemotes(alpha);
 280 });
 281
 282 test('Search for a post', async () => {
 283   await unfollowRemotes(alpha);
 284   let postRes = await createPost(alpha, betaCommunity.community.id);
 285   expect(postRes.post_view.post).toBeDefined();
 286
 287   let betaPost = (await resolvePost(beta, postRes.post_view.post)).post.unwrap();
 288   expect(betaPost.post.name).toBeDefined();
 289 });
 290
 291 test('Enforce site ban for federated user', async () => {
 292   // create a test user
 293   let alphaUserJwt = await registerUser(alpha);
 294   expect(alphaUserJwt).toBeDefined();
 295   let alpha_user: API = {
 296       client: alpha.client,
 297       auth: alphaUserJwt.jwt,
 298   };
 299   let alphaUserActorId = (await getSite(alpha_user)).my_user.unwrap().local_user_view.person.actor_id;
 300   expect(alphaUserActorId).toBeDefined();
 301   let alphaPerson = (await resolvePerson(alpha_user, alphaUserActorId)).person.unwrap();
 302   expect(alphaPerson).toBeDefined();
 303
 304   // alpha makes post in beta community, it federates to beta instance
 305   let postRes1 = await createPost(alpha_user, betaCommunity.community.id);
 306   let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
 307   expect(searchBeta1.posts[0]).toBeDefined();
 308
 309   // ban alpha from its instance
 310   let banAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, true, true);
 311   expect(banAlpha.banned).toBe(true);
 312
 313   // alpha ban should be federated to beta
 314   let alphaUserOnBeta1 = await resolvePerson(beta, alphaUserActorId);
 315   expect(alphaUserOnBeta1.person.unwrap().person.banned).toBe(true);
 316
 317   // existing alpha post should be removed on beta
 318   let searchBeta2 = await searchPostLocal(beta, postRes1.post_view.post);
 319   expect(searchBeta2.posts[0]).toBeUndefined();
 320
 321   // Unban alpha
 322   let unBanAlpha = await banPersonFromSite(alpha, alphaPerson.person.id, false, false);
 323   expect(unBanAlpha.banned).toBe(false);
 324
 325   // alpha makes new post in beta community, it federates
 326   let postRes2 = await createPost(alpha_user, betaCommunity.community.id);
 327   let searchBeta3 = await searchPostLocal(beta, postRes2.post_view.post);
 328   expect(searchBeta3.posts[0]).toBeDefined();
 329
 330   let alphaUserOnBeta2 = await resolvePerson(beta, alphaUserActorId)
 331   expect(alphaUserOnBeta2.person.unwrap().person.banned).toBe(false);
 332 });
 333
 334 test('Enforce community ban for federated user', async () => {
 335   let alphaShortname = `@lemmy_alpha@lemmy-alpha:8541`;
 336   let alphaPerson = (await resolvePerson(beta, alphaShortname)).person.unwrap();
 337   expect(alphaPerson).toBeDefined();
 338
 339   // make a post in beta, it goes through
 340   let postRes1 = await createPost(alpha, betaCommunity.community.id);
 341   let searchBeta1 = await searchPostLocal(beta, postRes1.post_view.post);
 342   expect(searchBeta1.posts[0]).toBeDefined();
 343
 344   // ban alpha from beta community
 345   let banAlpha = await banPersonFromCommunity(beta, alphaPerson.person.id, 2, true, true);
 346   expect(banAlpha.banned).toBe(true);
 347
 348   // ensure that the post by alpha got removed
 349   let searchAlpha1 = await searchPostLocal(alpha, postRes1.post_view.post);
 350   expect(searchAlpha1.posts[0]).toBeUndefined();
 351
 352   // Alpha tries to make post on beta, but it fails because of ban
 353   let postRes2 = await createPost(alpha, betaCommunity.community.id);
 354   expect(postRes2.post_view).toBeUndefined();
 355
 356   // Unban alpha
 357   let unBanAlpha = await banPersonFromCommunity(
 358     beta,
 359     alphaPerson.person.id,
 360     2,
 361     false,
 362     false
 363   );
 364   expect(unBanAlpha.banned).toBe(false);
 365   let postRes3 = await createPost(alpha, betaCommunity.community.id);
 366   expect(postRes3.post_view.post).toBeDefined();
 367   expect(postRes3.post_view.community.local).toBe(false);
 368   expect(postRes3.post_view.creator.local).toBe(true);
 369   expect(postRes3.post_view.counts.score).toBe(1);
 370
 371   // Make sure that post makes it to beta community
 372   let searchBeta2 = await searchPostLocal(beta, postRes3.post_view.post);
 373   expect(searchBeta2.posts[0]).toBeDefined();
 374 });
 375
 376
 377 test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
 378   let postRes = await createPost(alpha, betaCommunity.community.id);
 379   expect(postRes.post_view.post).toBeDefined();
 380
 381   let betaPost = (await resolvePost(gamma, postRes.post_view.post)).post.unwrap();
 382   expect(betaPost.post.name).toBeDefined();
 383 });
 384
 385 test('Report a post', async () => {
 386   let betaCommunity = (await resolveBetaCommunity(beta)).community.unwrap();
 387   let postRes = await createPost(beta, betaCommunity.community.id);
 388   expect(postRes.post_view.post).toBeDefined();
 389
 390   let alphaPost = (await resolvePost(alpha, postRes.post_view.post)).post.unwrap();
 391   let alphaReport = (await reportPost(alpha, alphaPost.post.id, randomString(10)))
 392         .post_report_view.post_report;
 393
 394   let betaReport = (await listPostReports(beta)).post_reports[0].post_report;
 395   expect(betaReport).toBeDefined();
 396   expect(betaReport.resolved).toBe(false);
 397   expect(betaReport.original_post_name).toBe(alphaReport.original_post_name);
 398   expect(betaReport.original_post_url.unwrapOr("none")).toBe(alphaReport.original_post_url.unwrapOr("none"));
 399   expect(betaReport.original_post_body.unwrapOr("none")).toBe(alphaReport.original_post_body.unwrapOr("none"));
 400   expect(betaReport.reason).toBe(alphaReport.reason);
 401 });