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