Begin integration test suite for appservice.

Author: Gnuxie

.github/workflows/mjolnir.yml

@@ -56,3 +56,25 @@ jobs:
       run: RUST_LOG=debug,hyper=info,rusttls=info mx-tester run
     - name: Cleanup
       run: mx-tester down
+  appservice-integration:
+    name: Application Service Integration tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-node@v3
+      with:
+        node-version: '16'
+    - name: Fetch and build mx-tester (cached across runs)
+      uses: baptiste0928/cargo-install@v1
+      with:
+        crate: mx-tester
+        version: "0.3.3"
+    - name: Setup image
+      run: RUST_LOG=debug,hyper=info,rusttls=info mx-tester build up
+    - name: Setup dependencies
+      run: yarn install
+    - name: Run tests
+      run: yarn test:appservice:integration
+    - name: Cleanup
+      run: mx-tester down

package.json

@@ -14,6 +14,7 @@
     "start:dev": "yarn build && node --async-stack-traces lib/index.js",
     "test": "ts-mocha --project ./tsconfig.json test/commands/**/*.ts",
     "test:integration": "NODE_ENV=harness ts-mocha --async-stack-traces --require test/integration/fixtures.ts --timeout 300000 --project ./tsconfig.json \"test/integration/**/*Test.ts\"",
+    "test:appservice:integration": "NODE_ENV=harness ts-mocha --async-stack-traces --exit --timeout 300000 --project ./tsconfig.json \"test/appservice/integration/**/*Test.ts\"",
     "test:manual": "NODE_ENV=harness ts-node test/integration/manualLaunchScript.ts",
     "version": "sed -i '/# version automated/s/[0-9][0-9]*\\.[0-9][0-9]*\\.[0-9][0-9]*/'$npm_package_version'/' synapse_antispam/setup.py && git add synapse_antispam/setup.py && cat synapse_antispam/setup.py"
   },

src/appservice/AppService.ts

@@ -27,9 +27,10 @@ export class MjolnirAppService {
 
     private constructor(
         public readonly config: IConfig,
-        private readonly bridge: Bridge,
+        public readonly bridge: Bridge,
         private readonly mjolnirManager: MjolnirManager,
         private readonly accessControl: AccessControl,
+        private readonly dataStore: DataStore,
     ) {
         this.api = new Api(config.homeserver.url, mjolnirManager);
     }
@@ -56,7 +57,8 @@ export class MjolnirAppService {
             config,
             bridge,
             mjolnirManager,
-            accessControl
+            accessControl,
+            dataStore
         );
         bridge.opts.controller = {
             onUserQuery: appService.onUserQuery.bind(appService),
@@ -89,12 +91,17 @@ export class MjolnirAppService {
         this.mjolnirManager.onEvent(request, context);
     }
 
-    private async start(port: number) {
+    public async start(port: number) {
         console.log("Matrix-side listening on port %s", port);
         this.api.start(this.config.webAPI.port);
         await this.bridge.listen(port);
     }
 
+    public async close(): Promise<void> {
+        await this.bridge.close();
+        await this.dataStore.close();
+    }
+
     public static generateRegistration(reg: AppServiceRegistration, callback: (finalRegisration: AppServiceRegistration) => void) {
         reg.setId(AppServiceRegistration.generateToken());
         reg.setHomeserverToken(AppServiceRegistration.generateToken());

src/appservice/datastore.ts

@@ -9,6 +9,8 @@ export interface MjolnirRecord {
 export interface DataStore {
     init(): Promise<void>;
 
+    close(): Promise<void>;
+
     list(): Promise<MjolnirRecord[]>;
 
     store(mjolnirRecord: MjolnirRecord): Promise<void>;
@@ -29,6 +31,10 @@ export class PgDataStore implements DataStore {
         await this.pgClient.connect();
     }
 
+    public async close(): Promise<void> {
+        await this.pgClient.end()
+    }
+
     public async list(): Promise<MjolnirRecord[]> {
         const result = await this.pgClient.query<MjolnirRecord>("SELECT local_part, owner, management_room FROM mjolnir");
 

test/appservice/integration/provisionTest.ts

@@ -0,0 +1,52 @@
+import { readTestConfig, setupHarness } from "../utils/harness";
+import { newTestUser } from "../../integration/clientHelper";
+import { getFirstReply } from "../../integration/commands/commandUtils";
+import { MatrixClient } from "matrix-bot-sdk";
+import { MjolnirAppService } from "../../../src/appservice/AppService";
+import PolicyList from "../../../src/models/PolicyList";
+import { CreateEvent } from "matrix-bot-sdk";
+
+interface Context extends Mocha.Context {
+    user?: MatrixClient,
+    appservice?:  MjolnirAppService
+}
+
+afterEach(function(this: Context) {
+    this.user?.stop();
+    // something still runs, and i'm not sure what? -- ignoring with --exit.
+    this.appservice?.close();
+});
+
+async function isPolicyRoom(user: MatrixClient, roomId: string): Promise<boolean> {
+    const createEvent = new CreateEvent(await user.getRoomStateEvent(roomId, "m.room.create", ""));
+    return PolicyList.ROOM_TYPE_VARIANTS.includes(createEvent.type);
+}
+
+describe("Test that the app service can provision a mjolnir on invite of the appservice bot", function () {
+    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 roomWeWantProtecting = await user.createRoom();
+        // have the user invite the appservice bot
+        this.user = user;
+        const roomsInvitedTo: string[] = [];
+        await new Promise(async resolve => {
+            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) {
+                    resolve(null);
+                }
+            });
+            await user.start();
+            await user.inviteUser(this.appservice!.bridge.getBot().getUserId(), roomWeWantProtecting);
+        });
+        await Promise.all(roomsInvitedTo.map(roomId => user.joinRoom(roomId)));
+        const managementRoomId = roomsInvitedTo.filter(async roomId => !(await isPolicyRoom(user, roomId)))[0];
+        await getFirstReply(user, managementRoomId, () => {
+            return user.sendMessage(managementRoomId, { body: `!mjolnir status`, msgtype: 'm.text' });
+        })
+    })
+})

test/appservice/utils/harness.ts

@@ -0,0 +1,22 @@
+import path from "path";
+import { MjolnirAppService } from "../../../src/appservice/AppService";
+import { ensureAliasedRoomExists } from "../../integration/mjolnirSetupUtils";
+import { read as configRead, IConfig } from "../../../src/appservice/config/config";
+import { PgDataStore } from "../../../src/appservice/datastore";
+import { newTestUser } from "../../integration/clientHelper";
+
+export function readTestConfig(): IConfig {
+    return configRead(path.join(__dirname, "../../../src/appservice/config/config.harness.yaml"));
+}
+
+// FIXME: do we need to tear these down? Well yes.
+export async function setupHarness(): Promise<MjolnirAppService> {
+    const config = readTestConfig();
+    const utilityUser = await newTestUser(config.homeserver.url, { name: { contains: "utility" }});
+    await ensureAliasedRoomExists(utilityUser, config.accessControlList);
+    const dataStore = new PgDataStore(config.db.connectionString);
+    await dataStore.init();
+    const appservice = await MjolnirAppService.makeMjolnirAppService(config, dataStore);
+    await appservice.start(9000);
+    return appservice;
+}

tsconfig.json

@@ -21,6 +21,7 @@
     },
     "include": [
         "./src/**/*",
+	"./test/appservice/*",
         "./test/integration/manualLaunchScript.ts",
         "./test/integration/roomMembersTest.ts",
         "./test/integration/banListTest.ts",