feat: Add E2E tests (#4)

tests/encryption.test.ts

@@ -0,0 +1,76 @@
+import puppeteer, { Browser, Page } from 'puppeteer';
+import path from 'path';
+import fs from 'fs-extra';
+import { nanoid } from 'nanoid';
+import openpgp, { key, message } from 'openpgp';
+
+const sleep = (time: number) => new Promise((resolve) => setTimeout(resolve, time));
+
+describe('encryption', () => {
+  let browser: Browser;
+  let page: Page;
+  let tmpDir: string;
+  let keys: key.KeyResult;
+
+  const getText = async (elm: any) => {
+    const text = await page.evaluate(el => el.textContent, elm);
+    return text;
+  }
+
+  beforeAll(async () => {
+    tmpDir = path.resolve(`.tmp/${nanoid}`);
+    await fs.mkdirp(tmpDir);
+    const data = await fs.readFile(
+      path.join(__dirname, '..', 'test-assets', 'key'),
+      'utf-8',
+    );
+    keys = await key.readArmored(data);
+  });
+
+  beforeEach(async () => {
+    browser = await puppeteer.launch({
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+      ]
+    });
+    page = await browser.newPage();
+    (page as any)._client.send('Page.setDownloadBehavior', {
+      behavior: 'allow',
+      downloadPath: tmpDir,
+    });
+    await page.goto(testUrl, {
+      waitUntil: 'networkidle2',
+    });
+  });
+
+  afterEach(async () => {
+    await browser.close();
+  });
+
+  it('should be able to encrypt a text', async () => {
+    await page.click('.send-btn');
+    await page.click('.add-text-tab');
+    await page.type('.msg-title', 'Foo');
+    await page.type('.msg-body', 'Bar');
+    await page.click('.msg-add');
+    await sleep(300);
+    const items = await page.$$('.msg-item');
+    expect(items.length).toBe(1);
+    const [item] = items;
+    const title = await item.$('.ant-list-item-meta-title');
+    const titleText = await getText(title);
+    expect(titleText).toBe('Foo.txt.asc');
+    await page.click('.msg-download');
+    await sleep(300);
+    const downloadPath = path.join(tmpDir, 'Foo.txt.asc');
+    expect(fs.existsSync(downloadPath)).toBe(true);
+    const data = await fs.readFile(downloadPath, 'utf-8');
+    
+    const decrypted = await openpgp.decrypt({
+      message: await message.readArmored(data),
+      privateKeys: keys.keys[0],
+    });
+    expect(decrypted.data).toBe('Bar');
+  });
+});

tests/env-ts.ts

@@ -0,0 +1,50 @@
+import NodeEnvironment from 'jest-environment-node';
+import { Server, createServer } from 'http';
+import getPort from 'get-port';
+import webpack from 'webpack';
+import path from 'path';
+import express from 'express';
+import createConfig from '../webpack.config';
+
+const build = () => new Promise<Server>(async (resolve, reject) => {
+  const config = await createConfig({
+    test: true,
+  });
+  const port = await getPort();
+  const bundler = webpack(config);
+  bundler.run((err, stats) => {
+    if (err) {
+      return reject(err);
+    } else if (stats.hasErrors()) {
+      return reject(new Error('Webpack errors'));
+    }
+    const app = express();
+    app.use(express.static(path.join(__dirname, '..', 'dist')));
+    const server = createServer(app);
+    const listener = server.listen(port, '127.0.0.1', () => {
+      resolve(listener);
+    });
+  });
+});
+
+class CustomEnvironment extends NodeEnvironment {
+  private _server?: Server;
+
+  constructor(config: any) {
+    super(config);
+  }
+
+  async setup() {
+    await super.setup();
+    this._server = await build();
+    const address: any = this._server?.address();
+    this.global.testUrl = `http://${address.address}:${address.port}`
+  }
+
+  async teardown() {
+    await super.teardown();
+    this._server?.close();
+  }
+}
+
+module.exports = CustomEnvironment;

tests/env.js

@@ -0,0 +1,4 @@
+require('ts-node/register');
+const Env = require('./env-ts');
+
+module.exports = Env;