start testing the web api used by the widget

Author: Gnuxie

src/appservice/Api.ts

@@ -100,6 +100,12 @@ export class Api {
         response.status(200).json(existing);
     }
 
+    /**
+     * Creates a new mjolnir for the requesting user and protects their first room.
+     * @param req.body.roomId The room id that the request to create a mjolnir originates from.
+     * This is so that mjolnir can protect the room once the authenticity of the request has been verified.
+     * @param req.body.openId An OpenID token to verify the send of the request with.
+     */
     private async pathCreate(req: express.Request, response: express.Response) {
         const accessToken = req.body["openId"];
         if (accessToken === undefined) {
@@ -119,12 +125,9 @@ export class Api {
             return;
         }
 
+        // TODO: provisionNewMjolnir will throw if it fails...
         const [mjolnirId, managementRoom] = await this.mjolnirManager.provisionNewMjolnir(userId);
 
-        // privisionNewMjolnir can't fail yet, but it should be able to
-        //if (mjolnirId === null) {
-        //}
-
         response.status(200).json({ mxid: mjolnirId, roomId: managementRoom });
     }
 

test/appservice/integration/webAPITest.ts

@@ -0,0 +1,54 @@
+import { MjolnirAppService } from "../../../src/appservice/AppService";
+import { newTestUser } from "../../integration/clientHelper";
+import { isPolicyRoom, readTestConfig, setupHarness } from "../utils/harness";
+import { CreateMjolnirResponse, MjolnirWebAPIClient } from "../utils/webAPIClient";
+import { MatrixClient } from "matrix-bot-sdk";
+import { getFirstReply } from "../../integration/commands/commandUtils";
+import expect from "expect";
+
+
+interface Context extends Mocha.Context {
+    appservice?: MjolnirAppService
+    user?: MatrixClient
+}
+
+
+describe("Test that the app service can provision a mjolnir when requested from the web API", function () {
+    afterEach(function(this: Context) {
+        this.user?.stop();
+        if (this.appservice) {
+            return this.appservice.close();
+        } else {
+            console.warn("Missing Appservice in this context, so cannot stop it.")
+        }
+    });
+    it("", async function (this: Context) {
+        const config = readTestConfig();
+        this.appservice = await setupHarness();
+        // create a user
+        const user = await newTestUser(config.homeserver.url, { name: { contains: "test" } });
+        const apiClient = await MjolnirWebAPIClient.makeClient(user, "http://localhost:9001");
+        const roomToProtectId = await user.createRoom({ preset: "public_chat" });
+
+        this.user = user;
+        const roomsInvitedTo: string[] = [];
+        const mjolnirDetails: CreateMjolnirResponse = await new Promise(async resolve => {
+            const mjolnirDetailsPromise = apiClient.createMjolnir(roomToProtectId);
+            user.on('room.invite', (roomId: string) => {
+                roomsInvitedTo.push(roomId)
+                // the appservice should invite it to a policy room and a management room.
+                if (roomsInvitedTo.length === 2) {
+                    mjolnirDetailsPromise.then(resolve);
+                }
+            });
+            await user.start();
+        });
+        await Promise.all(roomsInvitedTo.map(roomId => user.joinRoom(roomId)));
+        const managementRoomId = roomsInvitedTo.filter(async roomId => !(await isPolicyRoom(user, roomId)))[0];
+        expect(managementRoomId).toBe(mjolnirDetails.managementRoomId);
+        const event = await getFirstReply(user, managementRoomId, () => {
+            return user.sendMessage(managementRoomId, { body: `!mjolnir status`, msgtype: 'm.text' });
+        })
+        expect(event.sender).toBe(mjolnirDetails.mjolnirUserId);
+    })
+})

test/appservice/utils/webAPIClient.ts

@@ -0,0 +1,54 @@
+import * as request from "request";
+import { MatrixClient } from "matrix-bot-sdk";
+
+interface OpenIDTokenInfo {
+    access_token: string,
+    expires_in: number,
+    matrix_server_name: string,
+    token_type: string
+}
+
+async function getOpenIDToken(client: MatrixClient): Promise<string> {
+    const tokenInfo: OpenIDTokenInfo = await client.doRequest("POST", `/_matrix/client/v3/user/${await client.getUserId()}/openid/request_token`, undefined, {});
+    return tokenInfo.access_token;
+}
+
+export interface CreateMjolnirResponse {
+    mjolnirUserId: string,
+    managementRoomId: string,
+}
+
+export class MjolnirWebAPIClient {
+
+    private constructor(
+        private readonly matrixClient: MatrixClient,
+        /**
+         * This will want refactoring later on since, well, for some reason our API is designed to accept the token in request body and not authorization header :( 
+         * it will need to include the expiry for the token.
+         */
+        private readonly openIDToken: string,
+        private readonly baseURL: string,
+    ) {
+
+    }
+
+    public static async makeClient(client: MatrixClient, baseUrl: string): Promise<MjolnirWebAPIClient> {
+        const token = await getOpenIDToken(client);
+        return new MjolnirWebAPIClient(client, token, baseUrl);
+    }
+
+    public async createMjolnir(roomToProtectId: string): Promise<CreateMjolnirResponse> {
+        const body: { mxid: string, roomId: string } = await new Promise((resolve, reject) => {
+            request.post(`${this.baseURL}/create`, {
+                json: {
+                    openId: this.openIDToken,
+                    roomId: roomToProtectId,
+                },
+            }, (error, response) => error ? reject(error) : resolve(response.body))
+        });
+        return {
+            mjolnirUserId: body.mxid,
+            managementRoomId: body.roomId
+        }
+    }
+}