api_tests/src/user.spec.ts

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