1 import { None, Some, Option } from "@sniptt/monads";
35 PrivateMessageResponse,
36 PrivateMessagesResponse,
37 GetPersonMentionsResponse,
47 BanFromCommunityResponse,
50 ResolveObjectResponse,
55 ListPostReportsResponse,
57 CommentReportResponse,
59 ListCommentReportsResponse,
61 DeleteAccountResponse,
68 } from "lemmy-js-client";
70 export interface API {
75 export let alpha: API = {
76 client: new LemmyHttp("http://127.0.0.1:8541"),
80 export let beta: API = {
81 client: new LemmyHttp("http://127.0.0.1:8551"),
85 export let gamma: API = {
86 client: new LemmyHttp("http://127.0.0.1:8561"),
90 export let delta: API = {
91 client: new LemmyHttp("http://127.0.0.1:8571"),
95 export let epsilon: API = {
96 client: new LemmyHttp("http://127.0.0.1:8581"),
100 const password = "lemmylemmy";
102 export async function setupLogins() {
103 let formAlpha = new Login({
104 username_or_email: "lemmy_alpha",
107 let resAlpha = alpha.client.login(formAlpha);
109 let formBeta = new Login({
110 username_or_email: "lemmy_beta",
113 let resBeta = beta.client.login(formBeta);
115 let formGamma = new Login({
116 username_or_email: "lemmy_gamma",
119 let resGamma = gamma.client.login(formGamma);
121 let formDelta = new Login({
122 username_or_email: "lemmy_delta",
125 let resDelta = delta.client.login(formDelta);
127 let formEpsilon = new Login({
128 username_or_email: "lemmy_epsilon",
131 let resEpsilon = epsilon.client.login(formEpsilon);
133 let res = await Promise.all([
141 alpha.auth = res[0].jwt;
142 beta.auth = res[1].jwt;
143 gamma.auth = res[2].jwt;
144 delta.auth = res[3].jwt;
145 epsilon.auth = res[4].jwt;
147 // Registration applications are now enabled by default, need to disable them
148 let editSiteForm = new EditSite({
149 require_application: Some(false),
150 federation_debug: Some(true),
156 enable_downvotes: None,
157 open_registration: None,
159 community_creation_admin_only: None,
160 require_email_verification: None,
161 application_question: None,
162 private_instance: None,
164 default_post_listing_type: None,
165 legal_information: None,
166 application_email_admins: None,
167 hide_modlog_mod_names: None,
168 discussion_languages: None,
169 slur_filter_regex: None,
170 actor_name_max_length: None,
171 rate_limit_message: Some(999),
172 rate_limit_message_per_second: None,
173 rate_limit_post: Some(999),
174 rate_limit_post_per_second: None,
175 rate_limit_register: Some(999),
176 rate_limit_register_per_second: None,
177 rate_limit_image: Some(999),
178 rate_limit_image_per_second: None,
179 rate_limit_comment: Some(999),
180 rate_limit_comment_per_second: None,
181 rate_limit_search: Some(999),
182 rate_limit_search_per_second: None,
183 federation_enabled: None,
184 federation_worker_count: None,
185 captcha_enabled: None,
186 captcha_difficulty: None,
187 allowed_instances: None,
188 blocked_instances: None,
193 // Set the blocks and auths for each
194 editSiteForm.auth = alpha.auth.unwrap();
195 editSiteForm.allowed_instances = Some([
201 await alpha.client.editSite(editSiteForm);
203 editSiteForm.auth = beta.auth.unwrap();
204 editSiteForm.allowed_instances = Some([
210 await beta.client.editSite(editSiteForm);
212 editSiteForm.auth = gamma.auth.unwrap();
213 editSiteForm.allowed_instances = Some([
219 await gamma.client.editSite(editSiteForm);
221 editSiteForm.allowed_instances = Some(["lemmy-beta"]);
222 editSiteForm.auth = delta.auth.unwrap();
223 await delta.client.editSite(editSiteForm);
225 editSiteForm.auth = epsilon.auth.unwrap();
226 editSiteForm.allowed_instances = Some([]);
227 editSiteForm.blocked_instances = Some(["lemmy-alpha"]);
228 await epsilon.client.editSite(editSiteForm);
230 // Create the main alpha/beta communities
231 await createCommunity(alpha, "main");
232 await createCommunity(beta, "main");
235 export async function createPost(
238 ): Promise<PostResponse> {
239 let name = randomString(5);
240 let body = Some(randomString(10));
241 let url = Some("https://google.com/");
242 let form = new CreatePost({
246 auth: api.auth.unwrap(),
252 return api.client.createPost(form);
255 export async function editPost(api: API, post: Post): Promise<PostResponse> {
256 let name = Some("A jest test federated post, updated");
257 let form = new EditPost({
260 auth: api.auth.unwrap(),
266 return api.client.editPost(form);
269 export async function deletePost(
273 ): Promise<PostResponse> {
274 let form = new DeletePost({
277 auth: api.auth.unwrap(),
279 return api.client.deletePost(form);
282 export async function removePost(
286 ): Promise<PostResponse> {
287 let form = new RemovePost({
290 auth: api.auth.unwrap(),
293 return api.client.removePost(form);
296 export async function featurePost(
300 ): Promise<PostResponse> {
301 let form = new FeaturePost({
304 feature_type: PostFeatureType.Community,
305 auth: api.auth.unwrap(),
307 return api.client.featurePost(form);
310 export async function lockPost(
314 ): Promise<PostResponse> {
315 let form = new LockPost({
318 auth: api.auth.unwrap(),
320 return api.client.lockPost(form);
323 export async function resolvePost(
326 ): Promise<ResolveObjectResponse> {
327 let form = new ResolveObject({
331 return api.client.resolveObject(form);
334 export async function searchPostLocal(
337 ): Promise<SearchResponse> {
338 let form = new Search({
340 type_: Some(SearchType.Posts),
341 sort: Some(SortType.TopAll),
343 community_name: None,
350 return api.client.search(form);
353 export async function getPost(
356 ): Promise<GetPostResponse> {
357 let form = new GetPost({
362 return api.client.getPost(form);
365 export async function getComments(
368 ): Promise<GetCommentsResponse> {
369 let form = new GetComments({
370 post_id: Some(post_id),
371 type_: Some(ListingType.All),
372 sort: Some(CommentSortType.New), // TODO this sort might be wrong
377 community_name: None,
382 return api.client.getComments(form);
385 export async function resolveComment(
388 ): Promise<ResolveObjectResponse> {
389 let form = new ResolveObject({
393 return api.client.resolveObject(form);
396 export async function resolveBetaCommunity(
398 ): Promise<ResolveObjectResponse> {
399 // Use short-hand search url
400 let form = new ResolveObject({
401 q: "!main@lemmy-beta:8551",
404 return api.client.resolveObject(form);
407 export async function resolveCommunity(
410 ): Promise<ResolveObjectResponse> {
411 let form = new ResolveObject({
415 return api.client.resolveObject(form);
418 export async function resolvePerson(
421 ): Promise<ResolveObjectResponse> {
422 let form = new ResolveObject({
426 return api.client.resolveObject(form);
429 export async function banPersonFromSite(
434 ): Promise<BanPersonResponse> {
435 // Make sure lemmy-beta/c/main is cached on lemmy_alpha
436 let form = new BanPerson({
439 remove_data: Some(remove_data),
440 auth: api.auth.unwrap(),
444 return api.client.banPerson(form);
447 export async function banPersonFromCommunity(
450 community_id: number,
451 remove_data: boolean,
453 ): Promise<BanFromCommunityResponse> {
454 let form = new BanFromCommunity({
457 remove_data: Some(remove_data),
461 auth: api.auth.unwrap(),
463 return api.client.banFromCommunity(form);
466 export async function followCommunity(
470 ): Promise<CommunityResponse> {
471 let form = new FollowCommunity({
474 auth: api.auth.unwrap(),
476 return api.client.followCommunity(form);
479 export async function likePost(
483 ): Promise<PostResponse> {
484 let form = new CreatePostLike({
487 auth: api.auth.unwrap(),
490 return api.client.likePost(form);
493 export async function createComment(
496 parent_id: Option<number>,
497 content = "a jest test comment"
498 ): Promise<CommentResponse> {
499 let form = new CreateComment({
505 auth: api.auth.unwrap(),
507 return api.client.createComment(form);
510 export async function editComment(
513 content = Some("A jest test federated comment update")
514 ): Promise<CommentResponse> {
515 let form = new EditComment({
521 auth: api.auth.unwrap(),
523 return api.client.editComment(form);
526 export async function deleteComment(
530 ): Promise<CommentResponse> {
531 let form = new DeleteComment({
534 auth: api.auth.unwrap(),
536 return api.client.deleteComment(form);
539 export async function removeComment(
543 ): Promise<CommentResponse> {
544 let form = new RemoveComment({
548 auth: api.auth.unwrap(),
550 return api.client.removeComment(form);
553 export async function getMentions(
555 ): Promise<GetPersonMentionsResponse> {
556 let form = new GetPersonMentions({
557 sort: Some(CommentSortType.New),
558 unread_only: Some(false),
559 auth: api.auth.unwrap(),
563 return api.client.getPersonMentions(form);
566 export async function likeComment(
570 ): Promise<CommentResponse> {
571 let form = new CreateCommentLike({
572 comment_id: comment.id,
574 auth: api.auth.unwrap(),
576 return api.client.likeComment(form);
579 export async function createCommunity(
581 name_: string = randomString(5)
582 ): Promise<CommunityResponse> {
583 let description = Some("a sample description");
584 let form = new CreateCommunity({
591 posting_restricted_to_mods: None,
592 auth: api.auth.unwrap(),
594 return api.client.createCommunity(form);
597 export async function getCommunity(
600 ): Promise<CommunityResponse> {
601 let form = new GetCommunity({
606 return api.client.getCommunity(form);
609 export async function deleteCommunity(
613 ): Promise<CommunityResponse> {
614 let form = new DeleteCommunity({
617 auth: api.auth.unwrap(),
619 return api.client.deleteCommunity(form);
622 export async function removeCommunity(
626 ): Promise<CommunityResponse> {
627 let form = new RemoveCommunity({
632 auth: api.auth.unwrap(),
634 return api.client.removeCommunity(form);
637 export async function createPrivateMessage(
640 ): Promise<PrivateMessageResponse> {
641 let content = "A jest test federated private message";
642 let form = new CreatePrivateMessage({
645 auth: api.auth.unwrap(),
647 return api.client.createPrivateMessage(form);
650 export async function editPrivateMessage(
652 private_message_id: number
653 ): Promise<PrivateMessageResponse> {
654 let updatedContent = "A jest test federated private message edited";
655 let form = new EditPrivateMessage({
656 content: updatedContent,
658 auth: api.auth.unwrap(),
660 return api.client.editPrivateMessage(form);
663 export async function deletePrivateMessage(
666 private_message_id: number
667 ): Promise<PrivateMessageResponse> {
668 let form = new DeletePrivateMessage({
671 auth: api.auth.unwrap(),
673 return api.client.deletePrivateMessage(form);
676 export async function registerUser(
678 username: string = randomString(5)
679 ): Promise<LoginResponse> {
680 let form = new Register({
683 password_verify: password,
687 captcha_answer: None,
691 return api.client.register(form);
694 export async function saveUserSettingsBio(api: API): Promise<LoginResponse> {
695 let form = new SaveUserSettings({
696 show_nsfw: Some(true),
697 theme: Some("darkly"),
698 default_sort_type: Some(Object.keys(SortType).indexOf(SortType.Active)),
699 default_listing_type: Some(
700 Object.keys(ListingType).indexOf(ListingType.All)
702 interface_language: Some("en"),
703 show_avatars: Some(true),
704 send_notifications_to_email: Some(false),
705 bio: Some("a changed bio"),
710 matrix_user_id: None,
712 show_read_posts: None,
713 show_bot_accounts: None,
714 show_new_post_notifs: None,
716 discussion_languages: None,
717 auth: api.auth.unwrap(),
719 return saveUserSettings(api, form);
722 export async function saveUserSettingsFederated(
724 ): Promise<LoginResponse> {
725 let avatar = Some("https://image.flaticon.com/icons/png/512/35/35896.png");
726 let banner = Some("https://image.flaticon.com/icons/png/512/36/35896.png");
727 let bio = Some("a changed bio");
728 let form = new SaveUserSettings({
729 show_nsfw: Some(false),
731 default_sort_type: Some(Object.keys(SortType).indexOf(SortType.Hot)),
732 default_listing_type: Some(
733 Object.keys(ListingType).indexOf(ListingType.All)
735 interface_language: Some(""),
738 display_name: Some("user321"),
739 show_avatars: Some(false),
740 send_notifications_to_email: Some(false),
744 show_read_posts: None,
745 matrix_user_id: None,
747 show_bot_accounts: None,
748 show_new_post_notifs: None,
749 discussion_languages: None,
750 auth: api.auth.unwrap(),
752 return await saveUserSettings(alpha, form);
755 export async function saveUserSettings(
757 form: SaveUserSettings
758 ): Promise<LoginResponse> {
759 return api.client.saveUserSettings(form);
762 export async function deleteUser(api: API): Promise<DeleteAccountResponse> {
763 let form = new DeleteAccount({
764 auth: api.auth.unwrap(),
767 return api.client.deleteAccount(form);
770 export async function getSite(api: API): Promise<GetSiteResponse> {
771 let form = new GetSite({
774 return api.client.getSite(form);
777 export async function listPrivateMessages(
779 ): Promise<PrivateMessagesResponse> {
780 let form = new GetPrivateMessages({
781 auth: api.auth.unwrap(),
782 unread_only: Some(false),
786 return api.client.getPrivateMessages(form);
789 export async function unfollowRemotes(api: API): Promise<GetSiteResponse> {
790 // Unfollow all remote communities
791 let site = await getSite(api);
792 let remoteFollowed = site.my_user
794 .follows.filter(c => c.community.local == false);
795 for (let cu of remoteFollowed) {
796 await followCommunity(api, false, cu.community.id);
798 let siteRes = await getSite(api);
802 export async function followBeta(api: API): Promise<CommunityResponse> {
803 let betaCommunity = (await resolveBetaCommunity(api)).community;
804 if (betaCommunity.isSome()) {
805 let follow = await followCommunity(
808 betaCommunity.unwrap().community.id
812 return Promise.reject("no community worked");
816 export async function reportPost(
820 ): Promise<PostReportResponse> {
821 let form = new CreatePostReport({
824 auth: api.auth.unwrap(),
826 return api.client.createPostReport(form);
829 export async function listPostReports(
831 ): Promise<ListPostReportsResponse> {
832 let form = new ListPostReports({
833 auth: api.auth.unwrap(),
837 unresolved_only: None,
839 return api.client.listPostReports(form);
842 export async function reportComment(
846 ): Promise<CommentReportResponse> {
847 let form = new CreateCommentReport({
850 auth: api.auth.unwrap(),
852 return api.client.createCommentReport(form);
855 export async function listCommentReports(
857 ): Promise<ListCommentReportsResponse> {
858 let form = new ListCommentReports({
862 unresolved_only: None,
863 auth: api.auth.unwrap(),
865 return api.client.listCommentReports(form);
868 export function delay(millis = 500) {
869 return new Promise(resolve => setTimeout(resolve, millis));
872 export function longDelay() {
876 export function wrapper(form: any): string {
877 return JSON.stringify(form);
880 export function randomString(length: number): string {
883 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
884 var charactersLength = characters.length;
885 for (var i = 0; i < length; i++) {
886 result += characters.charAt(Math.floor(Math.random() * charactersLength));
891 export async function unfollows() {
892 await unfollowRemotes(alpha);
893 await unfollowRemotes(gamma);
894 await unfollowRemotes(delta);
895 await unfollowRemotes(epsilon);
898 export function getCommentParentId(comment: Comment): Option<number> {
899 let split = comment.path.split(".");
903 if (split.length > 1) {
904 return Some(Number(split[split.length - 2]));