Adding verbose to test results.

docker/federation-test/servers.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
 set -e
 
+sudo docker-compose --file ../federation/docker-compose.yml --project-directory . down
 sudo rm -rf volumes
 
 pushd ../../server/

docker/federation/docker-compose.yml

@@ -39,6 +39,8 @@ services:
       - LEMMY_SETUP__ADMIN_USERNAME=lemmy_alpha
       - LEMMY_SETUP__ADMIN_PASSWORD=lemmy
       - LEMMY_SETUP__SITE_NAME=lemmy-alpha
+      - LEMMY_RATE_LIMIT__POST=99999
+      - LEMMY_RATE_LIMIT__REGISTER=99999
       - RUST_BACKTRACE=1
       - RUST_LOG=debug
     depends_on:
@@ -66,6 +68,8 @@ services:
       - LEMMY_SETUP__ADMIN_USERNAME=lemmy_beta
       - LEMMY_SETUP__ADMIN_PASSWORD=lemmy
       - LEMMY_SETUP__SITE_NAME=lemmy-beta
+      - LEMMY_RATE_LIMIT__POST=99999
+      - LEMMY_RATE_LIMIT__REGISTER=99999
       - RUST_BACKTRACE=1
       - RUST_LOG=debug
     depends_on:
@@ -93,6 +97,8 @@ services:
       - LEMMY_SETUP__ADMIN_USERNAME=lemmy_gamma
       - LEMMY_SETUP__ADMIN_PASSWORD=lemmy
       - LEMMY_SETUP__SITE_NAME=lemmy-gamma
+      - LEMMY_RATE_LIMIT__POST=99999
+      - LEMMY_RATE_LIMIT__REGISTER=99999
       - RUST_BACKTRACE=1
       - RUST_LOG=debug
     depends_on:

docker/travis/docker-compose.yml

@@ -39,6 +39,8 @@ services:
       - LEMMY_SETUP__ADMIN_USERNAME=lemmy_alpha
       - LEMMY_SETUP__ADMIN_PASSWORD=lemmy
       - LEMMY_SETUP__SITE_NAME=lemmy-alpha
+      - LEMMY_RATE_LIMIT__POST=99999
+      - LEMMY_RATE_LIMIT__REGISTER=99999
       - RUST_BACKTRACE=1
       - RUST_LOG=debug
     depends_on:
@@ -66,6 +68,8 @@ services:
       - LEMMY_SETUP__ADMIN_USERNAME=lemmy_beta
       - LEMMY_SETUP__ADMIN_PASSWORD=lemmy
       - LEMMY_SETUP__SITE_NAME=lemmy-beta
+      - LEMMY_RATE_LIMIT__POST=99999
+      - LEMMY_RATE_LIMIT__REGISTER=99999
       - RUST_BACKTRACE=1
       - RUST_LOG=debug
     depends_on:
@@ -93,6 +97,8 @@ services:
       - LEMMY_SETUP__ADMIN_USERNAME=lemmy_gamma
       - LEMMY_SETUP__ADMIN_PASSWORD=lemmy
       - LEMMY_SETUP__SITE_NAME=lemmy-gamma
+      - LEMMY_RATE_LIMIT__POST=99999
+      - LEMMY_RATE_LIMIT__REGISTER=99999
       - RUST_BACKTRACE=1
       - RUST_LOG=debug
     depends_on:

server/lemmy_db/src/comment.rs

@@ -116,7 +116,10 @@ impl Comment {
   ) -> Result<Self, Error> {
     use crate::schema::comment::dsl::*;
     diesel::update(comment.find(comment_id))
-      .set(deleted.eq(new_deleted))
+      .set((
+        deleted.eq(new_deleted),
+        updated.eq(naive_now())
+      ))
       .get_result::<Self>(conn)
   }
 
@@ -127,7 +130,10 @@ impl Comment {
   ) -> Result<Self, Error> {
     use crate::schema::comment::dsl::*;
     diesel::update(comment.find(comment_id))
-      .set(removed.eq(new_removed))
+      .set((
+        removed.eq(new_removed),
+        updated.eq(naive_now())
+      ))
       .get_result::<Self>(conn)
   }
 

server/lemmy_db/src/community.rs

@@ -107,7 +107,10 @@ impl Community {
   ) -> Result<Self, Error> {
     use crate::schema::community::dsl::*;
     diesel::update(community.find(community_id))
-      .set(deleted.eq(new_deleted))
+      .set((
+        deleted.eq(new_deleted),
+        updated.eq(naive_now())
+      ))
       .get_result::<Self>(conn)
   }
 
@@ -118,7 +121,10 @@ impl Community {
   ) -> Result<Self, Error> {
     use crate::schema::community::dsl::*;
     diesel::update(community.find(community_id))
-      .set(removed.eq(new_removed))
+      .set((
+        removed.eq(new_removed),
+        updated.eq(naive_now())
+      ))
       .get_result::<Self>(conn)
   }
 

server/lemmy_db/src/post.rs

@@ -119,7 +119,10 @@ impl Post {
   ) -> Result<Self, Error> {
     use crate::schema::post::dsl::*;
     diesel::update(post.find(post_id))
-      .set(deleted.eq(new_deleted))
+      .set((
+        deleted.eq(new_deleted),
+        updated.eq(naive_now())
+      ))
       .get_result::<Self>(conn)
   }
 
@@ -130,7 +133,10 @@ impl Post {
   ) -> Result<Self, Error> {
     use crate::schema::post::dsl::*;
     diesel::update(post.find(post_id))
-      .set(removed.eq(new_removed))
+      .set((
+        removed.eq(new_removed),
+        updated.eq(naive_now())
+      ))
       .get_result::<Self>(conn)
   }
 

server/src/apub/inbox/user_inbox.rs

@@ -108,9 +108,9 @@ async fn receive_accept(
 
   // This will fail if they're already a follower
   blocking(pool, move |conn| {
-    CommunityFollower::follow(conn, &community_follower_form)
+    CommunityFollower::follow(conn, &community_follower_form).ok()
   })
-  .await??;
+  .await?;
 
   // TODO: make sure that we actually requested a follow
   Ok(HttpResponse::Ok().finish())

ui/package.json

@@ -6,7 +6,7 @@
   "license": "AGPL-3.0-or-later",
   "main": "index.js",
   "scripts": {
-    "api-test": "jest src/api_tests/api.spec.ts",
+    "api-test": "jest src/api_tests/ -i --verbose",
     "build": "node fuse prod",
     "lint": "tsc --noEmit && eslint --report-unused-disable-directives --ext .js,.ts,.tsx src",
     "prebuild": "node generate_translations.js",

ui/src/api_tests/comment.spec.ts

@@ -0,0 +1,308 @@
+import {
+  alpha,
+  beta,
+  gamma,
+  setupLogins,
+  createPost,
+  getPost,
+  searchComment,
+  likeComment,
+  followBeta,
+  searchForBetaCommunity,
+  createComment,
+  updateComment,
+  deleteComment,
+  removeComment,
+  getMentions,
+  searchPost,
+  unfollowRemotes,
+} from './shared';
+
+import { PostResponse } from '../interfaces';
+
+let postRes: PostResponse;
+
+beforeAll(async () => {
+  await setupLogins();
+  await followBeta(alpha);
+  await followBeta(gamma);
+  let search = await searchForBetaCommunity(alpha);
+  postRes = await createPost(
+    alpha,
+    search.communities.filter(c => c.local == false)[0].id
+  );
+});
+
+afterAll(async () => {
+  await unfollowRemotes(alpha);
+  await unfollowRemotes(gamma);
+});
+
+test('Create a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post.id);
+  expect(commentRes.comment.content).toBeDefined();
+  expect(commentRes.comment.community_local).toBe(false);
+  expect(commentRes.comment.creator_local).toBe(true);
+  expect(commentRes.comment.score).toBe(1);
+
+  // Make sure that comment is liked on beta
+  let searchBeta = await searchComment(beta, commentRes.comment);
+  let betaComment = searchBeta.comments[0];
+  expect(betaComment).toBeDefined();
+  expect(betaComment.community_local).toBe(true);
+  expect(betaComment.creator_local).toBe(false);
+  expect(betaComment.score).toBe(1);
+});
+
+test('Update a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post.id);
+  let updateCommentRes = await updateComment(alpha, commentRes.comment.id);
+  expect(updateCommentRes.comment.content).toBe(
+    'A jest test federated comment update'
+  );
+  expect(updateCommentRes.comment.community_local).toBe(false);
+  expect(updateCommentRes.comment.creator_local).toBe(true);
+
+  // Make sure that post is updated on beta
+  let searchBeta = await searchComment(beta, commentRes.comment);
+  let betaComment = searchBeta.comments[0];
+  expect(betaComment.content).toBe('A jest test federated comment update');
+});
+
+test('Delete a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post.id);
+  let deleteCommentRes = await deleteComment(
+    alpha,
+    true,
+    commentRes.comment.id
+  );
+  expect(deleteCommentRes.comment.deleted).toBe(true);
+
+  // Make sure that comment is deleted on beta
+  // The search doesnt work below, because it returns a tombstone / http::gone
+  // let searchBeta = await searchComment(beta, commentRes.comment);
+  // console.log(searchBeta);
+  // let betaComment = searchBeta.comments[0];
+  // Create a fake post, just to get the previous new post id
+  let createdBetaPostJustToGetId = await createPost(beta, 2);
+  let betaPost = await getPost(beta, createdBetaPostJustToGetId.post.id - 1);
+  let betaComment = betaPost.comments[0];
+  expect(betaComment.deleted).toBe(true);
+
+  let undeleteCommentRes = await deleteComment(
+    alpha,
+    false,
+    commentRes.comment.id
+  );
+  expect(undeleteCommentRes.comment.deleted).toBe(false);
+
+  // Make sure that comment is undeleted on beta
+  let searchBeta2 = await searchComment(beta, commentRes.comment);
+  let betaComment2 = searchBeta2.comments[0];
+  expect(betaComment2.deleted).toBe(false);
+});
+
+test('Remove a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post.id);
+  let removeCommentRes = await removeComment(
+    alpha,
+    true,
+    commentRes.comment.id
+  );
+  expect(removeCommentRes.comment.removed).toBe(true);
+
+  // Make sure that comment is removed on beta
+  let searchBeta = await searchComment(beta, commentRes.comment);
+  let betaComment = searchBeta.comments[0];
+  expect(betaComment.removed).toBe(true);
+
+  let unremoveCommentRes = await removeComment(
+    alpha,
+    false,
+    commentRes.comment.id
+  );
+  expect(unremoveCommentRes.comment.removed).toBe(false);
+
+  // Make sure that comment is unremoved on beta
+  let searchBeta2 = await searchComment(beta, commentRes.comment);
+  let betaComment2 = searchBeta2.comments[0];
+  expect(betaComment2.removed).toBe(false);
+});
+
+test('Unlike a comment', async () => {
+  let commentRes = await createComment(alpha, postRes.post.id);
+  let unlike = await likeComment(alpha, 0, commentRes.comment);
+  expect(unlike.comment.score).toBe(0);
+
+  // Make sure that post is unliked on beta
+  let searchBeta = await searchComment(beta, commentRes.comment);
+  let betaComment = searchBeta.comments[0];
+  expect(betaComment).toBeDefined();
+  expect(betaComment.community_local).toBe(true);
+  expect(betaComment.creator_local).toBe(false);
+  expect(betaComment.score).toBe(0);
+});
+
+test('Federated comment like', async () => {
+  let commentRes = await createComment(alpha, postRes.post.id);
+
+  // Find the comment on beta
+  let searchBeta = await searchComment(beta, commentRes.comment);
+  let betaComment = searchBeta.comments[0];
+
+  let like = await likeComment(beta, 1, betaComment);
+  expect(like.comment.score).toBe(2);
+
+  // Get the post from alpha, check the likes
+  let post = await getPost(alpha, postRes.post.id);
+  expect(post.comments[0].score).toBe(2);
+});
+
+test('Reply to a comment', async () => {
+  // Create a comment on alpha, find it on beta
+  let commentRes = await createComment(alpha, postRes.post.id);
+  let searchBeta = await searchComment(beta, commentRes.comment);
+  let betaComment = searchBeta.comments[0];
+
+  // find that comment id on beta
+
+  // Reply from beta
+  let replyRes = await createComment(beta, betaComment.post_id, betaComment.id);
+  expect(replyRes.comment.content).toBeDefined();
+  expect(replyRes.comment.community_local).toBe(true);
+  expect(replyRes.comment.creator_local).toBe(true);
+  expect(replyRes.comment.parent_id).toBe(betaComment.id);
+  expect(replyRes.comment.score).toBe(1);
+
+  // Make sure that comment is seen on alpha
+  // TODO not sure why, but a searchComment back to alpha, for the ap_id of betas
+  // comment, isn't working.
+  // let searchAlpha = await searchComment(alpha, replyRes.comment);
+  let post = await getPost(alpha, postRes.post.id);
+  let alphaComment = post.comments[0];
+  expect(alphaComment.content).toBeDefined();
+  expect(alphaComment.parent_id).toBe(post.comments[1].id);
+  expect(alphaComment.community_local).toBe(false);
+  expect(alphaComment.creator_local).toBe(false);
+  expect(alphaComment.score).toBe(1);
+});
+
+test('Mention beta', async () => {
+  // Create a mention on alpha
+  let mentionContent = 'A test mention of @lemmy_beta@lemmy-beta:8550';
+  let commentRes = await createComment(alpha, postRes.post.id);
+  let mentionRes = await createComment(
+    alpha,
+    postRes.post.id,
+    commentRes.comment.id,
+    mentionContent
+  );
+  expect(mentionRes.comment.content).toBeDefined();
+  expect(mentionRes.comment.community_local).toBe(false);
+  expect(mentionRes.comment.creator_local).toBe(true);
+  expect(mentionRes.comment.score).toBe(1);
+
+  let mentionsRes = await getMentions(beta);
+  expect(mentionsRes.mentions[0].content).toBeDefined();
+  expect(mentionsRes.mentions[0].community_local).toBe(true);
+  expect(mentionsRes.mentions[0].creator_local).toBe(false);
+  expect(mentionsRes.mentions[0].score).toBe(1);
+});
+
+test('Comment Search', async () => {
+  let commentRes = await createComment(alpha, postRes.post.id);
+  let searchBeta = await searchComment(beta, commentRes.comment);
+  expect(searchBeta.comments[0].ap_id).toBe(commentRes.comment.ap_id);
+});
+
+test('A and G subscribe to B (center) A posts, G mentions B, it gets announced to A', async () => {
+  // Create a local post
+  let alphaPost = await createPost(alpha, 2);
+  expect(alphaPost.post.community_local).toBe(true);
+
+  // Make sure gamma sees it
+  let search = await searchPost(gamma, alphaPost.post);
+  let gammaPost = search.posts[0];
+
+  let commentContent =
+    'A jest test federated comment announce, lets mention @lemmy_beta@lemmy-beta:8550';
+  let commentRes = await createComment(
+    gamma,
+    gammaPost.id,
+    undefined,
+    commentContent
+  );
+  expect(commentRes.comment.content).toBe(commentContent);
+  expect(commentRes.comment.community_local).toBe(false);
+  expect(commentRes.comment.creator_local).toBe(true);
+  expect(commentRes.comment.score).toBe(1);
+
+  // Make sure alpha sees it
+  let alphaPost2 = await getPost(alpha, alphaPost.post.id);
+  expect(alphaPost2.comments[0].content).toBe(commentContent);
+  expect(alphaPost2.comments[0].community_local).toBe(true);
+  expect(alphaPost2.comments[0].creator_local).toBe(false);
+  expect(alphaPost2.comments[0].score).toBe(1);
+
+  // Make sure beta has mentions
+  let mentionsRes = await getMentions(beta);
+  expect(mentionsRes.mentions[0].content).toBe(commentContent);
+  expect(mentionsRes.mentions[0].community_local).toBe(false);
+  expect(mentionsRes.mentions[0].creator_local).toBe(false);
+  // TODO this is failing because fetchInReplyTos aren't getting score
+  // expect(mentionsRes.mentions[0].score).toBe(1);
+});
+
+test('Fetch in_reply_tos: A is unsubbed from B, B makes a post, and some embedded comments, A subs to B, B updates the lowest level comment, A fetches both the post and all the inreplyto comments for that post.', async () => {
+  // Unfollow all remote communities
+  let followed = await unfollowRemotes(alpha);
+  expect(
+    followed.communities.filter(c => c.community_local == false).length
+  ).toBe(0);
+
+  // B creates a post, and two comments, should be invisible to A
+  let postRes = await createPost(beta, 2);
+  expect(postRes.post.name).toBeDefined();
+
+  let parentCommentContent = 'An invisible top level comment from beta';
+  let parentCommentRes = await createComment(
+    beta,
+    postRes.post.id,
+    undefined,
+    parentCommentContent
+  );
+  expect(parentCommentRes.comment.content).toBe(parentCommentContent);
+
+  // B creates a comment, then a child one of that.
+  let childCommentContent = 'An invisible child comment from beta';
+  let childCommentRes = await createComment(
+    beta,
+    postRes.post.id,
+    parentCommentRes.comment.id,
+    childCommentContent
+  );
+  expect(childCommentRes.comment.content).toBe(childCommentContent);
+
+  // Follow beta again
+  let follow = await followBeta(alpha);
+  expect(follow.community.local).toBe(false);
+  expect(follow.community.name).toBe('main');
+
+  // An update to the child comment on beta, should push the post, parent, and child to alpha now
+  let updatedCommentContent = 'An update child comment from beta';
+  let updateRes = await updateComment(
+    beta,
+    childCommentRes.comment.id,
+    updatedCommentContent
+  );
+  expect(updateRes.comment.content).toBe(updatedCommentContent);
+
+  // Get the post from alpha
+  let createFakeAlphaPostToGetId = await createPost(alpha, 2);
+  let alphaPost = await getPost(alpha, createFakeAlphaPostToGetId.post.id - 1);
+  expect(alphaPost.post.name).toBeDefined();
+  expect(alphaPost.comments[1].content).toBe(parentCommentContent);
+  expect(alphaPost.comments[0].content).toBe(updatedCommentContent);
+  expect(alphaPost.post.community_local).toBe(false);
+  expect(alphaPost.post.creator_local).toBe(false);
+});

ui/src/api_tests/community.spec.ts

@@ -0,0 +1,88 @@
+import {
+  alpha,
+  beta,
+  setupLogins,
+  searchForBetaCommunity,
+  createCommunity,
+  deleteCommunity,
+  removeCommunity,
+} from './shared';
+
+beforeAll(async () => {
+  await setupLogins();
+});
+
+test('Create community', async () => {
+  let communityRes = await createCommunity(alpha);
+  expect(communityRes.community.name).toBeDefined();
+
+  // A dupe check
+  let prevName = communityRes.community.name;
+  let communityRes2 = await createCommunity(alpha, prevName);
+  expect(communityRes2['error']).toBe('community_already_exists');
+});
+
+test('Delete community', async () => {
+  let communityRes = await createCommunity(beta);
+  let deleteCommunityRes = await deleteCommunity(
+    beta,
+    true,
+    communityRes.community.id
+  );
+  expect(deleteCommunityRes.community.deleted).toBe(true);
+
+  // Make sure it got deleted on A
+  let search = await searchForBetaCommunity(alpha);
+  let communityA = search.communities[0];
+  // TODO this fails currently, because no updates are pushed
+  // expect(communityA.deleted).toBe(true);
+
+  // Undelete
+  let undeleteCommunityRes = await deleteCommunity(
+    beta,
+    false,
+    communityRes.community.id
+  );
+  expect(undeleteCommunityRes.community.deleted).toBe(false);
+
+  // Make sure it got undeleted on A
+  let search2 = await searchForBetaCommunity(alpha);
+  let communityA2 = search2.communities[0];
+  // TODO this fails currently, because no updates are pushed
+  // expect(communityA2.deleted).toBe(false);
+});
+
+test('Remove community', async () => {
+  let communityRes = await createCommunity(beta);
+  let removeCommunityRes = await removeCommunity(
+    beta,
+    true,
+    communityRes.community.id
+  );
+  expect(removeCommunityRes.community.removed).toBe(true);
+
+  // Make sure it got removed on A
+  let search = await searchForBetaCommunity(alpha);
+  let communityA = search.communities[0];
+  // TODO this fails currently, because no updates are pushed
+  // expect(communityA.removed).toBe(true);
+
+  // unremove
+  let unremoveCommunityRes = await removeCommunity(
+    beta,
+    false,
+    communityRes.community.id
+  );
+  expect(unremoveCommunityRes.community.removed).toBe(false);
+
+  // Make sure it got unremoved on A
+  let search2 = await searchForBetaCommunity(alpha);
+  let communityA2 = search2.communities[0];
+  // TODO this fails currently, because no updates are pushed
+  // expect(communityA2.removed).toBe(false);
+});
+
+test('Search for beta community', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  expect(search.communities[0].name).toBe('main');
+});

ui/src/api_tests/follow.spec.ts

@@ -0,0 +1,40 @@
+import {
+  alpha,
+  setupLogins,
+  searchForBetaCommunity,
+  followCommunity,
+  checkFollowedCommunities,
+  unfollowRemotes,
+} from './shared';
+
+beforeAll(async () => {
+  await setupLogins();
+});
+
+afterAll(async () => {
+  await unfollowRemotes(alpha);
+});
+
+test('Follow federated community', async () => {
+  let search = await searchForBetaCommunity(alpha); // TODO sometimes this is returning null?
+  let follow = await followCommunity(alpha, true, search.communities[0].id);
+
+  // Make sure the follow response went through
+  expect(follow.community.local).toBe(false);
+  expect(follow.community.name).toBe('main');
+
+  // Check it from local
+  let followCheck = await checkFollowedCommunities(alpha);
+  let remoteCommunityId = followCheck.communities.filter(
+    c => c.community_local == false
+  )[0].community_id;
+  expect(remoteCommunityId).toBeDefined();
+
+  // Test an unfollow
+  let unfollow = await followCommunity(alpha, false, remoteCommunityId);
+  expect(unfollow.community.local).toBe(false);
+
+  // Make sure you are unsubbed locally
+  let unfollowCheck = await checkFollowedCommunities(alpha);
+  expect(unfollowCheck.communities.length).toBeGreaterThanOrEqual(1);
+});

ui/src/api_tests/post.spec.ts

@@ -0,0 +1,192 @@
+import {
+  alpha,
+  beta,
+  gamma,
+  setupLogins,
+  createPost,
+  updatePost,
+  stickyPost,
+  lockPost,
+  searchPost,
+  likePost,
+  followBeta,
+  searchForBetaCommunity,
+  createComment,
+  deletePost,
+  removePost,
+  getPost,
+  unfollowRemotes,
+} from './shared';
+
+beforeAll(async () => {
+  await setupLogins();
+  await followBeta(alpha);
+  await followBeta(gamma);
+});
+
+afterAll(async () => {
+  await unfollowRemotes(alpha);
+  await unfollowRemotes(gamma);
+});
+
+test('Create a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+  expect(postRes.post).toBeDefined();
+  expect(postRes.post.community_local).toBe(false);
+  expect(postRes.post.creator_local).toBe(true);
+  expect(postRes.post.score).toBe(1);
+
+  // Make sure that post is liked on beta
+  let searchBeta = await searchPost(beta, postRes.post);
+  let betaPost = searchBeta.posts[0];
+
+  expect(betaPost).toBeDefined();
+  expect(betaPost.community_local).toBe(true);
+  expect(betaPost.creator_local).toBe(false);
+  expect(betaPost.score).toBe(1);
+});
+
+test('Unlike a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+  let unlike = await likePost(alpha, 0, postRes.post);
+  expect(unlike.post.score).toBe(0);
+
+  // Make sure that post is unliked on beta
+  let searchBeta = await searchPost(beta, postRes.post);
+  let betaPost = searchBeta.posts[0];
+
+  expect(betaPost).toBeDefined();
+  expect(betaPost.community_local).toBe(true);
+  expect(betaPost.creator_local).toBe(false);
+  expect(betaPost.score).toBe(0);
+});
+
+test('Update a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+
+  let updatedPost = await updatePost(alpha, postRes.post);
+  expect(updatedPost.post.name).toBe('A jest test federated post, updated');
+  expect(updatedPost.post.community_local).toBe(false);
+  expect(updatedPost.post.creator_local).toBe(true);
+});
+
+test('Sticky a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+
+  let stickiedPostRes = await stickyPost(alpha, true, postRes.post);
+  expect(stickiedPostRes.post.stickied).toBe(true);
+
+  // Make sure that post is stickied on beta
+  let searchBeta = await searchPost(beta, postRes.post);
+  let betaPost = searchBeta.posts[0];
+  expect(betaPost.community_local).toBe(true);
+  expect(betaPost.creator_local).toBe(false);
+  expect(betaPost.stickied).toBe(true);
+
+  // Unsticky a post
+  let unstickiedPost = await stickyPost(alpha, false, postRes.post);
+  expect(unstickiedPost.post.stickied).toBe(false);
+
+  // Make sure that post is unstickied on beta
+  let searchBeta2 = await searchPost(beta, postRes.post);
+  let betaPost2 = searchBeta2.posts[0];
+  expect(betaPost2.community_local).toBe(true);
+  expect(betaPost2.creator_local).toBe(false);
+  expect(betaPost2.stickied).toBe(false);
+});
+
+test('Lock a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+
+  let lockedPostRes = await lockPost(alpha, true, postRes.post);
+  expect(lockedPostRes.post.locked).toBe(true);
+
+  // Make sure that post is locked on beta
+  let searchBeta = await searchPost(beta, postRes.post);
+  let betaPost = searchBeta.posts[0];
+  expect(betaPost.community_local).toBe(true);
+  expect(betaPost.creator_local).toBe(false);
+  expect(betaPost.locked).toBe(true);
+
+  // Try to make a new comment there, on alpha
+  let comment = await createComment(alpha, postRes.post.id);
+  expect(comment['error']).toBe('locked');
+
+  // Try to create a new comment, on beta
+  let commentBeta = await createComment(beta, betaPost.id);
+  expect(commentBeta['error']).toBe('locked');
+
+  // Unlock a post
+  let unlockedPost = await lockPost(alpha, false, postRes.post);
+  expect(unlockedPost.post.locked).toBe(false);
+
+  // Make sure that post is unlocked on beta
+  let searchBeta2 = await searchPost(beta, postRes.post);
+  let betaPost2 = searchBeta2.posts[0];
+  expect(betaPost2.community_local).toBe(true);
+  expect(betaPost2.creator_local).toBe(false);
+  expect(betaPost2.locked).toBe(false);
+});
+
+test('Delete a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+
+  let deletedPost = await deletePost(alpha, true, postRes.post);
+  expect(deletedPost.post.deleted).toBe(true);
+
+  // Make sure lemmy beta sees post is deleted
+  let createFakeBetaPostToGetId = (await createPost(beta, 2)).post.id - 1;
+  let betaPost = await getPost(beta, createFakeBetaPostToGetId);
+  expect(betaPost.post.deleted).toBe(true);
+
+  // Undelete
+  let undeletedPost = await deletePost(alpha, false, postRes.post);
+  expect(undeletedPost.post.deleted).toBe(false);
+
+  // Make sure lemmy beta sees post is undeleted
+  let betaPost2 = await getPost(beta, createFakeBetaPostToGetId);
+  expect(betaPost2.post.deleted).toBe(false);
+});
+
+test('Remove a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+
+  let removedPost = await removePost(alpha, true, postRes.post);
+  expect(removedPost.post.removed).toBe(true);
+
+  // Make sure lemmy beta sees post is removed
+  let createFakeBetaPostToGetId = (await createPost(beta, 2)).post.id - 1;
+  let betaPost = await getPost(beta, createFakeBetaPostToGetId);
+  expect(betaPost.post.removed).toBe(true);
+
+  // Undelete
+  let undeletedPost = await removePost(alpha, false, postRes.post);
+  expect(undeletedPost.post.removed).toBe(false);
+
+  // Make sure lemmy beta sees post is undeleted
+  let betaPost2 = await getPost(beta, createFakeBetaPostToGetId);
+  expect(betaPost2.post.removed).toBe(false);
+});
+
+test('Search for a post', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+  let searchBeta = await searchPost(beta, postRes.post);
+
+  expect(searchBeta.posts[0].name).toBeDefined();
+});
+
+test('A and G subscribe to B (center) A posts, it gets announced to G', async () => {
+  let search = await searchForBetaCommunity(alpha);
+  let postRes = await createPost(alpha, search.communities[0].id);
+
+  let search2 = await searchPost(gamma, postRes.post);
+  expect(search2.posts[0].name).toBeDefined();
+});

ui/src/api_tests/private_message.spec.ts

@@ -0,0 +1,71 @@
+import {
+  alpha,
+  beta,
+  setupLogins,
+  followBeta,
+  createPrivateMessage,
+  updatePrivateMessage,
+  listPrivateMessages,
+  deletePrivateMessage,
+  unfollowRemotes,
+} from './shared';
+
+let recipient_id: number;
+
+beforeAll(async () => {
+  await setupLogins();
+  recipient_id = (await followBeta(alpha)).community.creator_id;
+});
+
+afterAll(async () => {
+  await unfollowRemotes(alpha);
+});
+
+test('Create a private message', async () => {
+  let pmRes = await createPrivateMessage(alpha, recipient_id);
+  expect(pmRes.message.content).toBeDefined();
+  expect(pmRes.message.local).toBe(true);
+  expect(pmRes.message.creator_local).toBe(true);
+  expect(pmRes.message.recipient_local).toBe(false);
+
+  let betaPms = await listPrivateMessages(beta);
+  expect(betaPms.messages[0].content).toBeDefined();
+  expect(betaPms.messages[0].local).toBe(false);
+  expect(betaPms.messages[0].creator_local).toBe(false);
+  expect(betaPms.messages[0].recipient_local).toBe(true);
+});
+
+test('Update a private message', async () => {
+  let updatedContent = 'A jest test federated private message edited';
+
+  let pmRes = await createPrivateMessage(alpha, recipient_id);
+  let pmUpdated = await updatePrivateMessage(alpha, pmRes.message.id);
+  expect(pmUpdated.message.content).toBe(updatedContent);
+
+  let betaPms = await listPrivateMessages(beta);
+  expect(betaPms.messages[0].content).toBe(updatedContent);
+});
+
+test('Delete a private message', async () => {
+  let pmRes = await createPrivateMessage(alpha, recipient_id);
+  let betaPms1 = await listPrivateMessages(beta);
+  let deletedPmRes = await deletePrivateMessage(alpha, true, pmRes.message.id);
+  expect(deletedPmRes.message.deleted).toBe(true);
+
+  // The GetPrivateMessages filters out deleted,
+  // even though they are in the actual database.
+  // no reason to show them
+  let betaPms2 = await listPrivateMessages(beta);
+  expect(betaPms2.messages.length).toBe(betaPms1.messages.length - 1);
+
+  // Undelete
+  let undeletedPmRes = await deletePrivateMessage(
+    alpha,
+    false,
+    pmRes.message.id
+  );
+  expect(undeletedPmRes.message.deleted).toBe(false);
+
+  let betaPms3 = await listPrivateMessages(beta);
+  expect(betaPms3.messages.length).toBe(betaPms1.messages.length);
+});

ui/src/api_tests/shared.ts

@@ -0,0 +1,675 @@
+import fetch from 'node-fetch';
+
+import {
+  LoginForm,
+  LoginResponse,
+  Post,
+  PostForm,
+  Comment,
+  DeletePostForm,
+  RemovePostForm,
+  StickyPostForm,
+  LockPostForm,
+  PostResponse,
+  SearchResponse,
+  FollowCommunityForm,
+  CommunityResponse,
+  GetFollowedCommunitiesResponse,
+  GetPostResponse,
+  CommentForm,
+  DeleteCommentForm,
+  RemoveCommentForm,
+  CommentResponse,
+  CommunityForm,
+  DeleteCommunityForm,
+  RemoveCommunityForm,
+  CommentLikeForm,
+  CreatePostLikeForm,
+  PrivateMessageForm,
+  EditPrivateMessageForm,
+  DeletePrivateMessageForm,
+  PrivateMessageResponse,
+  PrivateMessagesResponse,
+  GetUserMentionsResponse,
+} from '../interfaces';
+
+export interface API {
+  url: string;
+  auth?: string;
+}
+
+function apiUrl(api: API) {
+  return `${api.url}/api/v1`;
+}
+
+export let alpha: API = {
+  url: 'http://localhost:8540',
+};
+
+export let beta: API = {
+  url: 'http://localhost:8550',
+};
+
+export let gamma: API = {
+  url: 'http://localhost:8560',
+};
+
+export async function setupLogins() {
+  let form: LoginForm = {
+    username_or_email: 'lemmy_alpha',
+    password: 'lemmy',
+  };
+
+  let resA: Promise<LoginResponse> = fetch(`${apiUrl(alpha)}/user/login`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(form),
+  }).then(d => d.json());
+
+  let formB = {
+    username_or_email: 'lemmy_beta',
+    password: 'lemmy',
+  };
+
+  let resB: Promise<LoginResponse> = fetch(`${apiUrl(beta)}/user/login`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(formB),
+  }).then(d => d.json());
+
+  let formC = {
+    username_or_email: 'lemmy_gamma',
+    password: 'lemmy',
+  };
+
+  let resG: Promise<LoginResponse> = fetch(`${apiUrl(gamma)}/user/login`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(formC),
+  }).then(d => d.json());
+
+  let res = await Promise.all([resA, resB, resG]);
+  alpha.auth = res[0].jwt;
+  beta.auth = res[1].jwt;
+  gamma.auth = res[2].jwt;
+}
+
+export async function createPost(
+  api: API,
+  community_id: number
+): Promise<PostResponse> {
+  let name = 'A jest test post';
+  let postForm: PostForm = {
+    name,
+    auth: api.auth,
+    community_id,
+    nsfw: false,
+  };
+
+  let createPostRes: PostResponse = await fetch(`${apiUrl(api)}/post`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(postForm),
+  }).then(d => d.json());
+  return createPostRes;
+}
+
+export async function updatePost(api: API, post: Post): Promise<PostResponse> {
+  let name = 'A jest test federated post, updated';
+  let postForm: PostForm = {
+    name,
+    edit_id: post.id,
+    auth: api.auth,
+    nsfw: false,
+  };
+
+  let updateResponse: PostResponse = await fetch(`${apiUrl(api)}/post`, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(postForm),
+  }).then(d => d.json());
+  return updateResponse;
+}
+
+export async function deletePost(
+  api: API,
+  deleted: boolean,
+  post: Post
+): Promise<PostResponse> {
+  let deletePostForm: DeletePostForm = {
+    edit_id: post.id,
+    deleted: deleted,
+    auth: api.auth,
+  };
+
+  let deletePostRes: PostResponse = await fetch(`${apiUrl(api)}/post/delete`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(deletePostForm),
+  }).then(d => d.json());
+  return deletePostRes;
+}
+
+export async function removePost(
+  api: API,
+  removed: boolean,
+  post: Post
+): Promise<PostResponse> {
+  let removePostForm: RemovePostForm = {
+    edit_id: post.id,
+    removed,
+    auth: api.auth,
+  };
+
+  let removePostRes: PostResponse = await fetch(`${apiUrl(api)}/post/remove`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(removePostForm),
+  }).then(d => d.json());
+  return removePostRes;
+}
+
+export async function stickyPost(
+  api: API,
+  stickied: boolean,
+  post: Post
+): Promise<PostResponse> {
+  let stickyPostForm: StickyPostForm = {
+    edit_id: post.id,
+    stickied,
+    auth: api.auth,
+  };
+
+  let stickyRes: PostResponse = await fetch(`${apiUrl(api)}/post/sticky`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(stickyPostForm),
+  }).then(d => d.json());
+
+  return stickyRes;
+}
+
+export async function lockPost(
+  api: API,
+  locked: boolean,
+  post: Post
+): Promise<PostResponse> {
+  let lockPostForm: LockPostForm = {
+    edit_id: post.id,
+    locked,
+    auth: api.auth,
+  };
+
+  let lockRes: PostResponse = await fetch(`${apiUrl(api)}/post/lock`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(lockPostForm),
+  }).then(d => d.json());
+
+  return lockRes;
+}
+
+export async function searchPost(
+  api: API,
+  post: Post
+): Promise<SearchResponse> {
+  let searchUrl = `${apiUrl(api)}/search?q=${post.ap_id}&type_=All&sort=TopAll`;
+  let searchResponse: SearchResponse = await fetch(searchUrl, {
+    method: 'GET',
+  }).then(d => d.json());
+  return searchResponse;
+}
+
+export async function getPost(
+  api: API,
+  post_id: number
+): Promise<GetPostResponse> {
+  let getPostUrl = `${apiUrl(api)}/post?id=${post_id}`;
+  let getPostRes: GetPostResponse = await fetch(getPostUrl, {
+    method: 'GET',
+  }).then(d => d.json());
+
+  return getPostRes;
+}
+
+export async function searchComment(
+  api: API,
+  comment: Comment
+): Promise<SearchResponse> {
+  let searchUrl = `${apiUrl(api)}/search?q=${
+    comment.ap_id
+  }&type_=All&sort=TopAll`;
+  let searchResponse: SearchResponse = await fetch(searchUrl, {
+    method: 'GET',
+  }).then(d => d.json());
+  return searchResponse;
+}
+
+export async function searchForBetaCommunity(
+  api: API
+): Promise<SearchResponse> {
+  // Make sure lemmy-beta/c/main is cached on lemmy_alpha
+  // Use short-hand search url
+  let searchUrl = `${apiUrl(
+    api
+  )}/search?q=!main@lemmy-beta:8550&type_=All&sort=TopAll`;
+
+  let searchResponse: SearchResponse = await fetch(searchUrl, {
+    method: 'GET',
+  }).then(d => d.json());
+  return searchResponse;
+}
+
+export async function followCommunity(
+  api: API,
+  follow: boolean,
+  community_id: number
+): Promise<CommunityResponse> {
+  let followForm: FollowCommunityForm = {
+    community_id,
+    follow,
+    auth: api.auth,
+  };
+
+  let followRes: CommunityResponse = await fetch(
+    `${apiUrl(api)}/community/follow`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(followForm),
+    }
+  )
+    .then(d => d.json())
+    .catch(_e => {});
+
+  return followRes;
+}
+
+export async function checkFollowedCommunities(
+  api: API
+): Promise<GetFollowedCommunitiesResponse> {
+  let followedCommunitiesUrl = `${apiUrl(
+    api
+  )}/user/followed_communities?&auth=${api.auth}`;
+  let followedCommunitiesRes: GetFollowedCommunitiesResponse = await fetch(
+    followedCommunitiesUrl,
+    {
+      method: 'GET',
+    }
+  ).then(d => d.json());
+  return followedCommunitiesRes;
+}
+
+export async function likePost(
+  api: API,
+  score: number,
+  post: Post
+): Promise<PostResponse> {
+  let likePostForm: CreatePostLikeForm = {
+    post_id: post.id,
+    score: score,
+    auth: api.auth,
+  };
+
+  let likePostRes: PostResponse = await fetch(`${apiUrl(api)}/post/like`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(likePostForm),
+  }).then(d => d.json());
+
+  return likePostRes;
+}
+
+export async function createComment(
+  api: API,
+  post_id: number,
+  parent_id?: number,
+  content = 'a jest test comment'
+): Promise<CommentResponse> {
+  let commentForm: CommentForm = {
+    content,
+    post_id,
+    parent_id,
+    auth: api.auth,
+  };
+
+  let createResponse: CommentResponse = await fetch(`${apiUrl(api)}/comment`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(commentForm),
+  }).then(d => d.json());
+  return createResponse;
+}
+
+export async function updateComment(
+  api: API,
+  edit_id: number,
+  content = 'A jest test federated comment update'
+): Promise<CommentResponse> {
+  let commentForm: CommentForm = {
+    content,
+    edit_id,
+    auth: api.auth,
+  };
+
+  let updateResponse: CommentResponse = await fetch(`${apiUrl(api)}/comment`, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: wrapper(commentForm),
+  }).then(d => d.json());
+  return updateResponse;
+}
+
+export async function deleteComment(
+  api: API,
+  deleted: boolean,
+  edit_id: number
+): Promise<CommentResponse> {
+  let deleteCommentForm: DeleteCommentForm = {
+    edit_id,
+    deleted,
+    auth: api.auth,
+  };
+
+  let deleteCommentRes: CommentResponse = await fetch(
+    `${apiUrl(api)}/comment/delete`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(deleteCommentForm),
+    }
+  ).then(d => d.json());
+  return deleteCommentRes;
+}
+
+export async function removeComment(
+  api: API,
+  removed: boolean,
+  edit_id: number
+): Promise<CommentResponse> {
+  let removeCommentForm: RemoveCommentForm = {
+    edit_id,
+    removed,
+    auth: api.auth,
+  };
+
+  let removeCommentRes: CommentResponse = await fetch(
+    `${apiUrl(api)}/comment/remove`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(removeCommentForm),
+    }
+  ).then(d => d.json());
+  return removeCommentRes;
+}
+
+export async function getMentions(api: API): Promise<GetUserMentionsResponse> {
+  let getMentionUrl = `${apiUrl(
+    api
+  )}/user/mention?sort=New&unread_only=false&auth=${api.auth}`;
+  let getMentionsRes: GetUserMentionsResponse = await fetch(getMentionUrl, {
+    method: 'GET',
+  }).then(d => d.json());
+  return getMentionsRes;
+}
+
+export async function likeComment(
+  api: API,
+  score: number,
+  comment: Comment
+): Promise<CommentResponse> {
+  let likeCommentForm: CommentLikeForm = {
+    comment_id: comment.id,
+    score,
+    auth: api.auth,
+  };
+
+  let likeCommentRes: CommentResponse = await fetch(
+    `${apiUrl(api)}/comment/like`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(likeCommentForm),
+    }
+  ).then(d => d.json());
+  return likeCommentRes;
+}
+
+export async function createCommunity(
+  api: API,
+  name_: string = randomString(5)
+): Promise<CommunityResponse> {
+  let communityForm: CommunityForm = {
+    name: name_,
+    title: name_,
+    category_id: 1,
+    nsfw: false,
+    auth: api.auth,
+  };
+
+  let createCommunityRes: CommunityResponse = await fetch(
+    `${apiUrl(api)}/community`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(communityForm),
+    }
+  ).then(d => d.json());
+  return createCommunityRes;
+}
+
+export async function deleteCommunity(
+  api: API,
+  deleted: boolean,
+  edit_id: number
+): Promise<CommunityResponse> {
+  let deleteCommunityForm: DeleteCommunityForm = {
+    edit_id,
+    deleted,
+    auth: api.auth,
+  };
+
+  let deleteResponse: CommunityResponse = await fetch(
+    `${apiUrl(api)}/community/delete`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(deleteCommunityForm),
+    }
+  ).then(d => d.json());
+  return deleteResponse;
+}
+
+export async function removeCommunity(
+  api: API,
+  removed: boolean,
+  edit_id: number
+): Promise<CommunityResponse> {
+  let removeCommunityForm: RemoveCommunityForm = {
+    edit_id,
+    removed,
+    auth: api.auth,
+  };
+
+  let removeResponse: CommunityResponse = await fetch(
+    `${apiUrl(api)}/community/remove`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(removeCommunityForm),
+    }
+  ).then(d => d.json());
+  return removeResponse;
+}
+
+export async function createPrivateMessage(
+  api: API,
+  recipient_id: number
+): Promise<PrivateMessageResponse> {
+  let content = 'A jest test federated private message';
+  let privateMessageForm: PrivateMessageForm = {
+    content,
+    recipient_id,
+    auth: api.auth,
+  };
+
+  let createRes: PrivateMessageResponse = await fetch(
+    `${apiUrl(api)}/private_message`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(privateMessageForm),
+    }
+  ).then(d => d.json());
+  return createRes;
+}
+
+export async function updatePrivateMessage(
+  api: API,
+  edit_id: number
+): Promise<PrivateMessageResponse> {
+  let updatedContent = 'A jest test federated private message edited';
+  let updatePrivateMessageForm: EditPrivateMessageForm = {
+    content: updatedContent,
+    edit_id,
+    auth: api.auth,
+  };
+
+  let updateRes: PrivateMessageResponse = await fetch(
+    `${apiUrl(api)}/private_message`,
+    {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(updatePrivateMessageForm),
+    }
+  ).then(d => d.json());
+  return updateRes;
+}
+
+export async function deletePrivateMessage(
+  api: API,
+  deleted: boolean,
+  edit_id: number
+): Promise<PrivateMessageResponse> {
+  let deletePrivateMessageForm: DeletePrivateMessageForm = {
+    deleted,
+    edit_id,
+    auth: api.auth,
+  };
+
+  let deleteRes: PrivateMessageResponse = await fetch(
+    `${apiUrl(api)}/private_message/delete`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: wrapper(deletePrivateMessageForm),
+    }
+  ).then(d => d.json());
+
+  return deleteRes;
+}
+
+export async function listPrivateMessages(
+  api: API
+): Promise<PrivateMessagesResponse> {
+  let getPrivateMessagesUrl = `${apiUrl(api)}/private_message/list?auth=${
+    api.auth
+  }&unread_only=false&limit=999`;
+
+  let getPrivateMessagesRes: PrivateMessagesResponse = await fetch(
+    getPrivateMessagesUrl,
+    {
+      method: 'GET',
+    }
+  ).then(d => d.json());
+  return getPrivateMessagesRes;
+}
+
+export async function unfollowRemotes(
+  api: API
+): Promise<GetFollowedCommunitiesResponse> {
+  // Unfollow all remote communities
+  let followed = await checkFollowedCommunities(api);
+  let remoteFollowed = followed.communities.filter(
+    c => c.community_local == false
+  );
+  for (let cu of remoteFollowed) {
+    await followCommunity(api, false, cu.community_id);
+  }
+  let followed2 = await checkFollowedCommunities(api);
+  return followed2;
+}
+
+export async function followBeta(api: API): Promise<CommunityResponse> {
+  await unfollowRemotes(api);
+
+  // Cache it
+  let search = await searchForBetaCommunity(api);
+
+  // Unfollow first
+  let follow = await followCommunity(
+    api,
+    true,
+    search.communities.filter(c => c.local == false)[0].id
+  );
+  return follow;
+}
+
+export function wrapper(form: any): string {
+  return JSON.stringify(form);
+}
+
+function randomString(length: number): string {
+  var result = '';
+  var characters = 'abcdefghijklmnopqrstuvwxyz0123456789_';
+  var charactersLength = characters.length;
+  for (var i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}