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