lemmy/api_tests/src/shared.ts

909 lines
20 KiB
TypeScript
Raw Normal View History

import { None, Some, Option } from "@sniptt/monads";
import {
2020-12-20 21:16:57 +00:00
Login,
LoginResponse,
2020-12-20 21:16:57 +00:00
CreatePost,
EditPost,
CreateComment,
DeletePost,
RemovePost,
LockPost,
PostResponse,
SearchResponse,
2020-12-20 21:16:57 +00:00
FollowCommunity,
CommunityResponse,
GetPostResponse,
2020-12-20 21:16:57 +00:00
Register,
Comment,
EditComment,
DeleteComment,
RemoveComment,
Search,
CommentResponse,
2020-12-20 21:16:57 +00:00
GetCommunity,
CreateCommunity,
DeleteCommunity,
RemoveCommunity,
2021-03-12 19:09:03 +00:00
GetPersonMentions,
2020-12-20 21:16:57 +00:00
CreateCommentLike,
CreatePostLike,
EditPrivateMessage,
DeletePrivateMessage,
GetPrivateMessages,
GetSite,
GetPost,
PrivateMessageResponse,
PrivateMessagesResponse,
2021-03-12 19:09:03 +00:00
GetPersonMentionsResponse,
2020-12-20 21:16:57 +00:00
SaveUserSettings,
SortType,
ListingType,
GetSiteResponse,
SearchType,
LemmyHttp,
2021-03-12 19:09:03 +00:00
BanPersonResponse,
BanPerson,
2020-12-20 21:16:57 +00:00
BanFromCommunity,
BanFromCommunityResponse,
2020-12-20 21:16:57 +00:00
Post,
CreatePrivateMessage,
ResolveObjectResponse,
ResolveObject,
CreatePostReport,
ListPostReports,
PostReportResponse,
ListPostReportsResponse,
CreateCommentReport,
CommentReportResponse,
ListCommentReports,
ListCommentReportsResponse,
DeleteAccount,
DeleteAccountResponse,
EditSite,
CommentSortType,
GetComments,
GetCommentsResponse,
FeaturePost,
PostFeatureType,
} from "lemmy-js-client";
export interface API {
client: LemmyHttp;
auth: Option<string>;
}
export let alpha: API = {
client: new LemmyHttp("http://127.0.0.1:8541"),
auth: None,
};
export let beta: API = {
client: new LemmyHttp("http://127.0.0.1:8551"),
auth: None,
};
export let gamma: API = {
client: new LemmyHttp("http://127.0.0.1:8561"),
auth: None,
};
export let delta: API = {
client: new LemmyHttp("http://127.0.0.1:8571"),
auth: None,
};
export let epsilon: API = {
client: new LemmyHttp("http://127.0.0.1:8581"),
auth: None,
};
const password = "lemmylemmy";
2021-09-19 21:20:47 +00:00
export async function setupLogins() {
let formAlpha = new Login({
username_or_email: "lemmy_alpha",
2021-09-19 21:20:47 +00:00
password,
});
let resAlpha = alpha.client.login(formAlpha);
let formBeta = new Login({
username_or_email: "lemmy_beta",
2021-09-19 21:20:47 +00:00
password,
});
let resBeta = beta.client.login(formBeta);
let formGamma = new Login({
username_or_email: "lemmy_gamma",
2021-09-19 21:20:47 +00:00
password,
});
let resGamma = gamma.client.login(formGamma);
let formDelta = new Login({
username_or_email: "lemmy_delta",
2021-09-19 21:20:47 +00:00
password,
});
let resDelta = delta.client.login(formDelta);
let formEpsilon = new Login({
username_or_email: "lemmy_epsilon",
2021-09-19 21:20:47 +00:00
password,
});
let resEpsilon = epsilon.client.login(formEpsilon);
let res = await Promise.all([
resAlpha,
resBeta,
resGamma,
resDelta,
resEpsilon,
]);
alpha.auth = res[0].jwt;
beta.auth = res[1].jwt;
gamma.auth = res[2].jwt;
delta.auth = res[3].jwt;
epsilon.auth = res[4].jwt;
// Registration applications are now enabled by default, need to disable them
let editSiteForm = new EditSite({
require_application: Some(false),
federation_debug: Some(true),
name: None,
sidebar: None,
description: None,
icon: None,
banner: None,
enable_downvotes: None,
open_registration: None,
enable_nsfw: None,
community_creation_admin_only: None,
require_email_verification: None,
application_question: None,
private_instance: None,
default_theme: None,
default_post_listing_type: None,
legal_information: None,
application_email_admins: None,
hide_modlog_mod_names: None,
discussion_languages: None,
slur_filter_regex: None,
actor_name_max_length: None,
rate_limit_message: Some(999),
rate_limit_message_per_second: None,
rate_limit_post: Some(999),
rate_limit_post_per_second: None,
rate_limit_register: Some(999),
rate_limit_register_per_second: None,
rate_limit_image: Some(999),
rate_limit_image_per_second: None,
rate_limit_comment: Some(999),
rate_limit_comment_per_second: None,
rate_limit_search: Some(999),
rate_limit_search_per_second: None,
federation_enabled: None,
federation_worker_count: None,
captcha_enabled: None,
captcha_difficulty: None,
allowed_instances: None,
blocked_instances: None,
auth: "",
taglines: None,
});
// Set the blocks and auths for each
editSiteForm.auth = alpha.auth.unwrap();
editSiteForm.allowed_instances = Some([
"lemmy-beta",
"lemmy-gamma",
"lemmy-delta",
"lemmy-epsilon",
]);
await alpha.client.editSite(editSiteForm);
editSiteForm.auth = beta.auth.unwrap();
editSiteForm.allowed_instances = Some([
"lemmy-alpha",
"lemmy-gamma",
"lemmy-delta",
"lemmy-epsilon",
]);
await beta.client.editSite(editSiteForm);
editSiteForm.auth = gamma.auth.unwrap();
editSiteForm.allowed_instances = Some([
"lemmy-alpha",
"lemmy-beta",
"lemmy-delta",
"lemmy-epsilon",
]);
await gamma.client.editSite(editSiteForm);
editSiteForm.allowed_instances = Some(["lemmy-beta"]);
editSiteForm.auth = delta.auth.unwrap();
await delta.client.editSite(editSiteForm);
editSiteForm.auth = epsilon.auth.unwrap();
editSiteForm.allowed_instances = Some([]);
editSiteForm.blocked_instances = Some(["lemmy-alpha"]);
await epsilon.client.editSite(editSiteForm);
// Create the main alpha/beta communities
await createCommunity(alpha, "main");
await createCommunity(beta, "main");
}
export async function createPost(
api: API,
community_id: number
): Promise<PostResponse> {
let name = randomString(5);
let body = Some(randomString(10));
let url = Some("https://google.com/");
let form = new CreatePost({
name,
url,
body,
auth: api.auth.unwrap(),
community_id,
nsfw: None,
honeypot: None,
language_id: None,
});
return api.client.createPost(form);
}
2020-12-20 21:16:57 +00:00
export async function editPost(api: API, post: Post): Promise<PostResponse> {
let name = Some("A jest test federated post, updated");
let form = new EditPost({
name,
post_id: post.id,
auth: api.auth.unwrap(),
nsfw: None,
url: None,
body: None,
language_id: None,
});
return api.client.editPost(form);
}
export async function deletePost(
api: API,
deleted: boolean,
post: Post
): Promise<PostResponse> {
let form = new DeletePost({
post_id: post.id,
deleted: deleted,
auth: api.auth.unwrap(),
});
return api.client.deletePost(form);
}
export async function removePost(
api: API,
removed: boolean,
post: Post
): Promise<PostResponse> {
let form = new RemovePost({
post_id: post.id,
removed,
auth: api.auth.unwrap(),
reason: None,
});
return api.client.removePost(form);
}
export async function featurePost(
api: API,
featured: boolean,
post: Post
): Promise<PostResponse> {
let form = new FeaturePost({
post_id: post.id,
featured,
feature_type: PostFeatureType.Community,
auth: api.auth.unwrap(),
});
return api.client.featurePost(form);
}
export async function lockPost(
api: API,
locked: boolean,
post: Post
): Promise<PostResponse> {
let form = new LockPost({
post_id: post.id,
locked,
auth: api.auth.unwrap(),
});
return api.client.lockPost(form);
}
export async function resolvePost(
api: API,
post: Post
): Promise<ResolveObjectResponse> {
let form = new ResolveObject({
q: post.ap_id,
auth: api.auth,
});
return api.client.resolveObject(form);
}
export async function searchPostLocal(
api: API,
post: Post
): Promise<SearchResponse> {
let form = new Search({
q: post.name,
type_: Some(SearchType.Posts),
sort: Some(SortType.TopAll),
community_id: None,
community_name: None,
creator_id: None,
listing_type: None,
page: None,
limit: None,
auth: api.auth,
});
return api.client.search(form);
}
export async function getPost(
api: API,
post_id: number
): Promise<GetPostResponse> {
let form = new GetPost({
id: Some(post_id),
comment_id: None,
auth: api.auth,
});
return api.client.getPost(form);
}
export async function getComments(
api: API,
post_id: number
): Promise<GetCommentsResponse> {
let form = new GetComments({
post_id: Some(post_id),
type_: Some(ListingType.All),
sort: Some(CommentSortType.New), // TODO this sort might be wrong
max_depth: None,
page: None,
limit: None,
community_id: None,
community_name: None,
saved_only: None,
parent_id: None,
auth: api.auth,
});
return api.client.getComments(form);
}
export async function resolveComment(
api: API,
comment: Comment
): Promise<ResolveObjectResponse> {
let form = new ResolveObject({
q: comment.ap_id,
auth: api.auth,
});
return api.client.resolveObject(form);
}
export async function resolveBetaCommunity(
api: API
): Promise<ResolveObjectResponse> {
// Use short-hand search url
let form = new ResolveObject({
q: "!main@lemmy-beta:8551",
auth: api.auth,
});
return api.client.resolveObject(form);
}
export async function resolveCommunity(
api: API,
2020-12-20 21:16:57 +00:00
q: string
): Promise<ResolveObjectResponse> {
let form = new ResolveObject({
q,
auth: api.auth,
});
return api.client.resolveObject(form);
}
export async function resolvePerson(
api: API,
apShortname: string
): Promise<ResolveObjectResponse> {
let form = new ResolveObject({
q: apShortname,
auth: api.auth,
});
return api.client.resolveObject(form);
}
2021-03-12 19:09:03 +00:00
export async function banPersonFromSite(
api: API,
2021-03-12 19:09:03 +00:00
person_id: number,
ban: boolean,
remove_data: boolean
2021-03-12 19:09:03 +00:00
): Promise<BanPersonResponse> {
// Make sure lemmy-beta/c/main is cached on lemmy_alpha
let form = new BanPerson({
2021-03-12 19:09:03 +00:00
person_id,
ban,
remove_data: Some(remove_data),
auth: api.auth.unwrap(),
reason: None,
expires: None,
});
2021-03-12 19:09:03 +00:00
return api.client.banPerson(form);
}
2021-03-12 19:09:03 +00:00
export async function banPersonFromCommunity(
api: API,
2021-03-12 19:09:03 +00:00
person_id: number,
community_id: number,
remove_data: boolean,
2020-12-20 21:16:57 +00:00
ban: boolean
): Promise<BanFromCommunityResponse> {
let form = new BanFromCommunity({
2021-03-12 19:09:03 +00:00
person_id,
community_id,
remove_data: Some(remove_data),
ban,
reason: None,
expires: None,
auth: api.auth.unwrap(),
});
return api.client.banFromCommunity(form);
}
export async function followCommunity(
api: API,
follow: boolean,
community_id: number
): Promise<CommunityResponse> {
let form = new FollowCommunity({
community_id,
follow,
auth: api.auth.unwrap(),
});
return api.client.followCommunity(form);
}
export async function likePost(
api: API,
score: number,
post: Post
): Promise<PostResponse> {
let form = new CreatePostLike({
post_id: post.id,
score: score,
auth: api.auth.unwrap(),
});
return api.client.likePost(form);
}
export async function createComment(
api: API,
post_id: number,
parent_id: Option<number>,
content = "a jest test comment"
): Promise<CommentResponse> {
let form = new CreateComment({
content,
post_id,
parent_id,
form_id: None,
language_id: None,
auth: api.auth.unwrap(),
});
return api.client.createComment(form);
}
2020-12-20 21:16:57 +00:00
export async function editComment(
api: API,
comment_id: number,
content = Some("A jest test federated comment update")
): Promise<CommentResponse> {
let form = new EditComment({
content,
comment_id,
form_id: None,
language_id: None,
distinguished: None,
auth: api.auth.unwrap(),
});
return api.client.editComment(form);
}
export async function deleteComment(
api: API,
deleted: boolean,
comment_id: number
): Promise<CommentResponse> {
let form = new DeleteComment({
comment_id,
deleted,
auth: api.auth.unwrap(),
});
return api.client.deleteComment(form);
}
export async function removeComment(
api: API,
removed: boolean,
comment_id: number
): Promise<CommentResponse> {
let form = new RemoveComment({
comment_id,
removed,
reason: None,
auth: api.auth.unwrap(),
});
return api.client.removeComment(form);
}
export async function getMentions(
api: API
): Promise<GetPersonMentionsResponse> {
let form = new GetPersonMentions({
sort: Some(CommentSortType.New),
unread_only: Some(false),
auth: api.auth.unwrap(),
page: None,
limit: None,
});
2021-03-12 19:09:03 +00:00
return api.client.getPersonMentions(form);
}
export async function likeComment(
api: API,
score: number,
comment: Comment
): Promise<CommentResponse> {
let form = new CreateCommentLike({
comment_id: comment.id,
score,
auth: api.auth.unwrap(),
});
return api.client.likeComment(form);
}
export async function createCommunity(
api: API,
name_: string = randomString(5)
): Promise<CommunityResponse> {
let description = Some("a sample description");
let form = new CreateCommunity({
name: name_,
title: name_,
description,
nsfw: None,
icon: None,
banner: None,
posting_restricted_to_mods: None,
auth: api.auth.unwrap(),
});
return api.client.createCommunity(form);
}
export async function getCommunity(
api: API,
2020-12-20 21:16:57 +00:00
id: number
): Promise<CommunityResponse> {
let form = new GetCommunity({
id: Some(id),
name: None,
auth: api.auth,
});
return api.client.getCommunity(form);
}
export async function deleteCommunity(
api: API,
deleted: boolean,
community_id: number
): Promise<CommunityResponse> {
let form = new DeleteCommunity({
community_id,
deleted,
auth: api.auth.unwrap(),
});
return api.client.deleteCommunity(form);
}
export async function removeCommunity(
api: API,
removed: boolean,
community_id: number
): Promise<CommunityResponse> {
let form = new RemoveCommunity({
community_id,
removed,
reason: None,
expires: None,
auth: api.auth.unwrap(),
});
return api.client.removeCommunity(form);
}
export async function createPrivateMessage(
api: API,
recipient_id: number
): Promise<PrivateMessageResponse> {
let content = "A jest test federated private message";
let form = new CreatePrivateMessage({
content,
recipient_id,
auth: api.auth.unwrap(),
});
return api.client.createPrivateMessage(form);
}
2020-12-20 21:16:57 +00:00
export async function editPrivateMessage(
api: API,
private_message_id: number
): Promise<PrivateMessageResponse> {
let updatedContent = "A jest test federated private message edited";
let form = new EditPrivateMessage({
content: updatedContent,
private_message_id,
auth: api.auth.unwrap(),
});
return api.client.editPrivateMessage(form);
}
export async function deletePrivateMessage(
api: API,
deleted: boolean,
private_message_id: number
): Promise<PrivateMessageResponse> {
let form = new DeletePrivateMessage({
deleted,
private_message_id,
auth: api.auth.unwrap(),
});
return api.client.deletePrivateMessage(form);
}
export async function registerUser(
api: API,
username: string = randomString(5)
): Promise<LoginResponse> {
let form = new Register({
username,
2021-09-19 21:20:47 +00:00
password,
password_verify: password,
show_nsfw: true,
email: None,
captcha_uuid: None,
captcha_answer: None,
honeypot: None,
answer: None,
});
return api.client.register(form);
}
export async function saveUserSettingsBio(api: API): Promise<LoginResponse> {
let form = new SaveUserSettings({
show_nsfw: Some(true),
theme: Some("darkly"),
default_sort_type: Some(Object.keys(SortType).indexOf(SortType.Active)),
default_listing_type: Some(
Object.keys(ListingType).indexOf(ListingType.All)
),
interface_language: Some("en"),
show_avatars: Some(true),
send_notifications_to_email: Some(false),
bio: Some("a changed bio"),
avatar: None,
banner: None,
display_name: None,
email: None,
matrix_user_id: None,
show_scores: None,
show_read_posts: None,
show_bot_accounts: None,
show_new_post_notifs: None,
bot_account: None,
discussion_languages: None,
auth: api.auth.unwrap(),
});
return saveUserSettings(api, form);
}
export async function saveUserSettingsFederated(
api: API
): Promise<LoginResponse> {
let avatar = Some("https://image.flaticon.com/icons/png/512/35/35896.png");
let banner = Some("https://image.flaticon.com/icons/png/512/36/35896.png");
let bio = Some("a changed bio");
let form = new SaveUserSettings({
show_nsfw: Some(false),
theme: Some(""),
default_sort_type: Some(Object.keys(SortType).indexOf(SortType.Hot)),
default_listing_type: Some(
Object.keys(ListingType).indexOf(ListingType.All)
),
interface_language: Some(""),
avatar,
banner,
display_name: Some("user321"),
show_avatars: Some(false),
send_notifications_to_email: Some(false),
bio,
email: None,
show_scores: None,
show_read_posts: None,
matrix_user_id: None,
bot_account: None,
show_bot_accounts: None,
show_new_post_notifs: None,
discussion_languages: None,
auth: api.auth.unwrap(),
});
return await saveUserSettings(alpha, form);
}
export async function saveUserSettings(
api: API,
2020-12-20 21:16:57 +00:00
form: SaveUserSettings
): Promise<LoginResponse> {
return api.client.saveUserSettings(form);
}
export async function deleteUser(api: API): Promise<DeleteAccountResponse> {
let form = new DeleteAccount({
auth: api.auth.unwrap(),
password,
});
return api.client.deleteAccount(form);
}
export async function getSite(api: API): Promise<GetSiteResponse> {
let form = new GetSite({
auth: api.auth,
});
return api.client.getSite(form);
}
export async function listPrivateMessages(
api: API
): Promise<PrivateMessagesResponse> {
let form = new GetPrivateMessages({
auth: api.auth.unwrap(),
unread_only: Some(false),
page: None,
limit: None,
});
return api.client.getPrivateMessages(form);
}
export async function unfollowRemotes(api: API): Promise<GetSiteResponse> {
// Unfollow all remote communities
let site = await getSite(api);
let remoteFollowed = site.my_user
.unwrap()
.follows.filter(c => c.community.local == false);
for (let cu of remoteFollowed) {
2020-12-20 21:16:57 +00:00
await followCommunity(api, false, cu.community.id);
}
let siteRes = await getSite(api);
return siteRes;
}
export async function followBeta(api: API): Promise<CommunityResponse> {
let betaCommunity = (await resolveBetaCommunity(api)).community;
if (betaCommunity.isSome()) {
let follow = await followCommunity(
api,
true,
betaCommunity.unwrap().community.id
);
return follow;
} else {
return Promise.reject("no community worked");
}
}
export async function reportPost(
api: API,
post_id: number,
reason: string
): Promise<PostReportResponse> {
let form = new CreatePostReport({
post_id,
reason,
auth: api.auth.unwrap(),
});
return api.client.createPostReport(form);
}
export async function listPostReports(
api: API
): Promise<ListPostReportsResponse> {
let form = new ListPostReports({
auth: api.auth.unwrap(),
page: None,
limit: None,
community_id: None,
unresolved_only: None,
});
return api.client.listPostReports(form);
}
export async function reportComment(
api: API,
comment_id: number,
reason: string
): Promise<CommentReportResponse> {
let form = new CreateCommentReport({
comment_id,
reason,
auth: api.auth.unwrap(),
});
return api.client.createCommentReport(form);
}
export async function listCommentReports(
api: API
): Promise<ListCommentReportsResponse> {
let form = new ListCommentReports({
page: None,
limit: None,
community_id: None,
unresolved_only: None,
auth: api.auth.unwrap(),
});
return api.client.listCommentReports(form);
}
export function delay(millis = 500) {
2020-12-20 21:16:57 +00:00
return new Promise(resolve => setTimeout(resolve, millis));
2020-10-01 13:32:01 +00:00
}
export function longDelay() {
return delay(10000);
}
export function wrapper(form: any): string {
return JSON.stringify(form);
}
export function randomString(length: number): string {
var result = "";
var characters =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
var charactersLength = characters.length;
for (var i = 0; i < length; i++) {
result += characters.charAt(Math.floor(Math.random() * charactersLength));
}
return result;
}
2022-03-22 19:50:47 +00:00
export async function unfollows() {
await unfollowRemotes(alpha);
await unfollowRemotes(gamma);
await unfollowRemotes(delta);
await unfollowRemotes(epsilon);
}
export function getCommentParentId(comment: Comment): Option<number> {
let split = comment.path.split(".");
// remove the 0
split.shift();
if (split.length > 1) {
return Some(Number(split[split.length - 2]));
} else {
return None;
}
}