api_tests/src/user.spec.ts

   1 jest.setTimeout(120000);
   2 import { None } from "@sniptt/monads";
   3 import { PersonViewSafe } from "lemmy-js-client";
   4
   5 import {
   6   alpha,
   7   beta,
   8   registerUser,
   9   resolvePerson,
  10   getSite,
  11   createPost,
  12   resolveCommunity,
  13   createComment,
  14   resolveBetaCommunity,
  15   deleteUser,
  16   resolvePost,
  17   API,
  18   resolveComment,
  19   saveUserSettingsFederated,
  20   setupLogins,
  21 } from "./shared";
  22
  23 beforeAll(async () => {
  24   await setupLogins();
  25 });
  26
  27 let apShortname: string;
  28
  29 function assertUserFederation(
  30   userOne: PersonViewSafe,
  31   userTwo: PersonViewSafe
  32 ) {
  33   expect(userOne.person.name).toBe(userTwo.person.name);
  34   expect(userOne.person.display_name.unwrapOr("none")).toBe(
  35     userTwo.person.display_name.unwrapOr("none")
  36   );
  37   expect(userOne.person.bio.unwrapOr("none")).toBe(
  38     userTwo.person.bio.unwrapOr("none")
  39   );
  40   expect(userOne.person.actor_id).toBe(userTwo.person.actor_id);
  41   expect(userOne.person.avatar.unwrapOr("none")).toBe(
  42     userTwo.person.avatar.unwrapOr("none")
  43   );
  44   expect(userOne.person.banner.unwrapOr("none")).toBe(
  45     userTwo.person.banner.unwrapOr("none")
  46   );
  47   expect(userOne.person.published).toBe(userTwo.person.published);
  48 }
  49
  50 test("Create user", async () => {
  51   let userRes = await registerUser(alpha);
  52   expect(userRes.jwt).toBeDefined();
  53   alpha.auth = userRes.jwt;
  54
  55   let site = await getSite(alpha);
  56   expect(site.my_user).toBeDefined();
  57   apShortname = `@${
  58     site.my_user.unwrap().local_user_view.person.name
  59   }@lemmy-alpha:8541`;
  60 });
  61
  62 test("Set some user settings, check that they are federated", async () => {
  63   await saveUserSettingsFederated(alpha);
  64   let alphaPerson = (await resolvePerson(alpha, apShortname)).person.unwrap();
  65   let betaPerson = (await resolvePerson(beta, apShortname)).person.unwrap();
  66   assertUserFederation(alphaPerson, betaPerson);
  67 });
  68
  69 test("Delete user", async () => {
  70   let userRes = await registerUser(alpha);
  71   expect(userRes.jwt).toBeDefined();
  72   let user: API = {
  73     client: alpha.client,
  74     auth: userRes.jwt,
  75   };
  76
  77   // make a local post and comment
  78   let alphaCommunity = (
  79     await resolveCommunity(user, "!main@lemmy-alpha:8541")
  80   ).community.unwrap();
  81   let localPost = (await createPost(user, alphaCommunity.community.id))
  82     .post_view.post;
  83   expect(localPost).toBeDefined();
  84   let localComment = (await createComment(user, localPost.id, None))
  85     .comment_view.comment;
  86   expect(localComment).toBeDefined();
  87
  88   // make a remote post and comment
  89   let betaCommunity = (await resolveBetaCommunity(user)).community.unwrap();
  90   let remotePost = (await createPost(user, betaCommunity.community.id))
  91     .post_view.post;
  92   expect(remotePost).toBeDefined();
  93   let remoteComment = (await createComment(user, remotePost.id, None))
  94     .comment_view.comment;
  95   expect(remoteComment).toBeDefined();
  96
  97   await deleteUser(user);
  98
  99   expect((await resolvePost(alpha, localPost)).post.isNone()).toBe(true);
 100   expect((await resolveComment(alpha, localComment)).comment.isNone()).toBe(
 101     true
 102   );
 103   expect((await resolvePost(alpha, remotePost)).post.isNone()).toBe(true);
 104   expect((await resolveComment(alpha, remoteComment)).comment.isNone()).toBe(
 105     true
 106   );
 107 });