New project structure

Beta of extract.js for extracting english locale

server/test/e2e/lib/config.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const config = require('server/test/e2e/lib/config');
+
+module.exports = {
+    app: config,
+    baseUrl: 'http://localhost:' + config.www.publicPort,
+    mailUrl: 'http://localhost:' + config.testServer.mailboxServerPort,
+    users: {
+        admin: {
+            username: 'admin',
+            password: 'test',
+            email: 'keep.admin@mailtrain.org',
+            accessToken: '7833d148e22c85474c314f43ae4591a7c9adec26'
+        }
+    },
+    lists: {
+        l1: {
+            id: 1,
+            cid: 'Hkj1vCoJb',
+            publicSubscribe: 1,
+            unsubscriptionMode: 0, // (one-step, no form)
+            customFields: [
+                { type: 'text', key: 'MERGE_TEXT', column: 'custom_text_field_byiiqjrw' },
+                { type: 'number', key: 'MERGE_NUMBER', column: 'custom_number_field_r1dd91awb' },
+                { type: 'website', key: 'MERGE_WEBSITE', column: 'custom_website_field_rkq991cw' },
+                { type: 'gpg', key: 'MERGE_GPG_PUBLIC_KEY', column: 'custom_gpg_public_key_ryvj51cz' },
+                { type: 'longtext', key: 'MERGE_MULTILINE_TEXT', column: 'custom_multiline_text_bjbfojawb' },
+                { type: 'json', key: 'MERGE_JSON', column: 'custom_json_skqjkcb' },
+                { type: 'date-us', key: 'MERGE_DATE_MMDDYYYY', column: 'custom_date_mmddyy_rjkeojrzz' },
+                { type: 'date-eur', key: 'MERGE_DATE_DDMMYYYY', column: 'custom_date_ddmmyy_ryedsk0wz' },
+                { type: 'birthday-us', key: 'MERGE_BIRTHDAY_MMDD', column: 'custom_birthday_mmdd_h18coj0zz' },
+                { type: 'birthday-eur', key: 'MERGE_BIRTHDAY_DDMM', column: 'custom_birthday_ddmm_r1g3s1czz' },
+                // TODO: Add remaining custom fields, dropdowns and checkboxes
+            ]
+        },
+        l2: {
+            id: 2,
+            cid: 'SktV4HDZ-',
+            publicSubscribe: 1,
+            unsubscriptionMode: 1, // (one-step, with form)
+            customFields: []
+        },
+        l3: {
+            id: 3,
+            cid: 'BkdvNBw-W',
+            publicSubscribe: 1,
+            unsubscriptionMode: 2, // (two-step, no form)
+            customFields: []
+        },
+        l4: {
+            id: 4,
+            cid: 'rJMKVrDZ-',
+            publicSubscribe: 1,
+            unsubscriptionMode: 3, // (two-step, with form)
+            customFields: []
+        },
+        l5: {
+            id: 5,
+            cid: 'SJgoNSw-W',
+            publicSubscribe: 1,
+            unsubscriptionMode: 4, // (manual unsubscribe)
+            customFields: []
+        },
+        l6: {
+            id: 6,
+            cid: 'HyveEPvWW',
+            publicSubscribe: 0,
+            unsubscriptionMode: 0, // (one-step, no form)
+            customFields: []
+        }
+    },
+    settings: {
+        'service-url': 'http://localhost:' + config.www.publicPort + '/',
+        'admin-email': 'keep.admin@mailtrain.org',
+        'default-homepage': 'https://mailtrain.org',
+        'smtp-hostname': config.testServer.host,
+        'smtp-port': config.testServer.port,
+        'smtp-encryption': 'NONE',
+        'smtp-user': config.testServer.username,
+        'smtp-pass': config.testServer.password
+    }
+};

server/test/e2e/lib/exit-unless-test.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const config = require('./config');
+const log = require('npmlog');
+const path = require('path');
+const fs = require('fs');
+
+if (process.env.NODE_ENV !== 'test' || !fs.existsSync(path.join(__dirname, '..', '..', '..', 'config', 'test.toml'))) {
+    log.error('e2e', 'This script only runs in test and config/test.toml (i.e. a dedicated test database) is present');
+    process.exit(1);
+}
+
+if (config.app.testServer.enabled !== true) {
+    log.error('e2e', 'This script only runs if the testServer is enabled. Check config/test.toml');
+    process.exit(1);
+}
+
+if (config.app.www.port !== 3000) {
+    log.error('e2e', 'This script requires Mailtrain to be running on port 3000. Check config/test.toml');
+    process.exit(1);
+}

server/test/e2e/lib/mail.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const config = require('./config');
+const driver = require('./mocha-e2e').driver;
+const page = require('./page');
+
+module.exports = (...extras) => page({
+
+    async fetchMail(address) {
+        await driver.sleep(1000);
+        await driver.navigate().to(`${config.mailUrl}/${address}`);
+        await this.waitUntilVisible();
+    },
+
+    async ensureUrl() {
+        throw new Error('Unsupported method.');
+    }
+
+}, ...extras);

server/test/e2e/lib/mocha-e2e.js

@@ -0,0 +1,213 @@
+'use strict';
+
+/* eslint-disable no-console */
+
+const Mocha = require('mocha');
+const color = Mocha.reporters.Base.color;
+const WorkerCounter = require('./worker-counter');
+const fs = require('fs-extra');
+const config = require('./config');
+const webdriver = require('selenium-webdriver');
+
+const driver = new webdriver.Builder()
+    .forBrowser(config.app.seleniumWebDriver.browser || 'phantomjs')
+    .build();
+
+const failHandlerRunning = new WorkerCounter();
+
+function UseCaseReporter(runner) {
+    Mocha.reporters.Base.call(this, runner);
+
+    const self = this;
+    let indents = 0;
+
+    function indent () {
+        return Array(indents).join('  ');
+    }
+
+    runner.on('start', () => {
+        console.log();
+    });
+
+    runner.on('suite', suite => {
+        ++indents;
+        console.log(color('suite', '%s%s'), indent(), suite.title);
+    });
+
+    runner.on('suite end', () => {
+        --indents;
+        if (indents === 1) {
+            console.log();
+        }
+    });
+
+    runner.on('use-case', useCase => {
+        ++indents;
+        console.log();
+        console.log(color('suite', '%sUse case: %s'), indent(), useCase.title);
+    });
+
+    runner.on('use-case end', () => {
+        --indents;
+    });
+
+    runner.on('steps', useCase => {
+        ++indents;
+        console.log(color('pass', '%s%s'), indent(), useCase.title);
+    });
+
+    runner.on('steps end', () => {
+        --indents;
+    });
+
+    runner.on('step pass', step => {
+        console.log(indent() + color('checkmark', '  ' + Mocha.reporters.Base.symbols.ok) + color('pass', ' %s'), step.title);
+    });
+
+    runner.on('step fail', step => {
+        console.log(indent() + color('fail', '  %s'), step.title);
+    });
+
+    runner.on('pending', test => {
+        const fmt = indent() + color('pending', '  - %s');
+        console.log(fmt, test.title);
+    });
+
+    runner.on('pass', test => {
+        let fmt;
+        if (test.speed === 'fast') {
+            fmt = indent() +
+                color('checkmark', '  ' + Mocha.reporters.Base.symbols.ok) +
+                color('pass', ' %s');
+            console.log(fmt, test.title);
+        } else {
+            fmt = indent() +
+                color('checkmark', '  ' + Mocha.reporters.Base.symbols.ok) +
+                color('pass', ' %s') +
+                color(test.speed, ' (%dms)');
+            console.log(fmt, test.title, test.duration);
+        }
+    });
+
+    runner.on('fail', (test, err) => {
+        failHandlerRunning.enter();
+        (async () => {
+            const currentUrl = await driver.getCurrentUrl();
+            const info = `URL: ${currentUrl}`;
+            await fs.writeFile('last-failed-e2e-test.info', info);
+            await fs.writeFile('last-failed-e2e-test.html', await driver.getPageSource());
+            await fs.writeFile('last-failed-e2e-test.png', Buffer.from(await driver.takeScreenshot(), 'base64'));
+            failHandlerRunning.exit();
+        })();
+
+        console.log(indent() + color('fail', '  %s'), test.title);
+        console.log();
+        console.log(err);
+        console.log();
+        console.log('Snaphot of and info about the current page are in last-failed-e2e-test.*');
+    });
+
+    runner.on('end', () => {
+        const stats = self.stats;
+        let fmt;
+
+        console.log();
+
+        // passes
+        fmt = color('bright pass', ' ') + color('green', ' %d passing');
+        console.log(fmt, stats.passes);
+
+        // pending
+        if (stats.pending) {
+            fmt = color('pending', ' ') + color('pending', ' %d pending');
+            console.log(fmt, stats.pending);
+        }
+
+        // failures
+        if (stats.failures) {
+            fmt = color('fail', '  %d failing');
+            console.log(fmt, stats.failures);
+        }
+
+        console.log();
+    });
+}
+
+
+const mocha = new Mocha()
+    .timeout(120000)
+    .reporter(UseCaseReporter)
+    .ui('tdd');
+
+mocha._originalRun = mocha.run;
+
+
+let runner;
+mocha.run = fn => {
+    runner = mocha._originalRun(async () => {
+        await failHandlerRunning.waitForEmpty();
+        await driver.quit();
+
+        fn();
+    });
+};
+
+
+async function useCaseExec(name, asyncFn) {
+    runner.emit('use-case', {title: name});
+
+    try {
+        await asyncFn();
+        runner.emit('use-case end');
+    } catch (err) {
+        runner.emit('use-case end');
+        throw err;
+    }
+}
+
+function useCase(name, asyncFn) {
+    if (asyncFn) {
+        return test('Use case: ' + name, () => useCaseExec(name, asyncFn));
+    } else {
+        // Pending test
+        return test('Use case: ' + name);
+    }
+}
+
+useCase.only = (name, asyncFn) => test.only('Use case: ' + name, () => useCaseExec(name, asyncFn));
+
+useCase.skip = (name, asyncFn) => test.skip('Use case: ' + name, () => useCaseExec(name, asyncFn));
+
+async function step(name, asyncFn) {
+    try {
+        await asyncFn();
+        runner.emit('step pass', {title: name});
+    } catch (err) {
+        runner.emit('step fail', {title: name});
+        throw err;
+    }
+}
+
+async function steps(name, asyncFn) {
+    try {
+        runner.emit('steps', {title: name});
+        await asyncFn();
+        runner.emit('steps end');
+    } catch (err) {
+        runner.emit('step end');
+        throw err;
+    }
+}
+
+async function precondition(preConditionName, useCaseName, asyncFn) {
+    await steps(`Including use case "${useCaseName}" to satisfy precondition "${preConditionName}"`, asyncFn);
+}
+
+module.exports = {
+    mocha,
+    useCase,
+    step,
+    steps,
+    precondition,
+    driver
+};

server/test/e2e/lib/page.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const webdriver = require('selenium-webdriver');
+const By = webdriver.By;
+const until = webdriver.until;
+const fs = require('fs-extra');
+const driver = require('./mocha-e2e').driver;
+const url = require('url');
+const UrlPattern = require('url-pattern');
+
+const waitTimeout = 10000;
+
+module.exports = (...extras) => Object.assign({
+    elements: {},
+
+    async getElement(key) {
+        return await driver.findElement(By.css(this.elements[key] || key));
+    },
+
+    async getLinkParams(key) {
+        const elem = await driver.findElement(By.css(this.elements[key]));
+
+        const linkUrl = await elem.getAttribute('href');
+        const linkPath = url.parse(linkUrl).path;
+
+        const urlPattern = new UrlPattern(this.links[key]);
+
+        const params = urlPattern.match(linkPath);
+        if (!params) {
+            throw new Error(`Cannot match URL pattern ${this.links[key]}`);
+        }
+        return params;
+    },
+
+    async waitUntilVisible(selector) {
+        await driver.wait(until.elementLocated(By.css('body')), waitTimeout);
+
+        if (selector) {
+            await driver.wait(until.elementLocated(By.css(selector)), waitTimeout);
+        }
+
+        for (const elem of (this.elementsToWaitFor || [])) {
+            const sel = this.elements[elem];
+            if (!sel) {
+                throw new Error(`Element "${elem}" not found.`);
+            }
+            await driver.wait(until.elementLocated(By.css(sel)), waitTimeout);
+        }
+
+        for (const text of (this.textsToWaitFor || [])) {
+            await driver.wait(new webdriver.Condition(`for text "${text}"`, async () => await this.containsText(text)), waitTimeout);
+        }
+
+        if (this.url) {
+            await this.ensureUrl();
+        }
+
+        await driver.executeScript('document.mailTrainRefreshAcknowledged = true;');
+    },
+
+    async waitUntilVisibleAfterRefresh(selector) {
+        await driver.wait(new webdriver.Condition('for refresh', async driver => {
+            const val = await driver.executeScript('return document.mailTrainRefreshAcknowledged;');
+            return !val;
+        }), waitTimeout);
+
+        await this.waitUntilVisible(selector);
+    },
+
+    async click(key) {
+        const elem = await this.getElement(key);
+        await elem.click();
+    },
+
+    async getHref(key) {
+        const elem = await this.getElement(key);
+        return await elem.getAttribute('href');
+    },
+
+    async getText(key) {
+        const elem = await this.getElement(key);
+        return await elem.getText();
+    },
+
+    async getValue(key) {
+        const elem = await this.getElement(key);
+        return await elem.getAttribute('value');
+    },
+
+    async containsText(str) {
+        return await driver.executeScript(`
+            return (document.documentElement.innerText || document.documentElement.textContent).indexOf('${str}') > -1;
+        `);
+    },
+
+    async getSource() {
+        return await driver.getPageSource();
+    },
+
+    async saveSource(destPath) {
+        const src = await this.getSource();
+        await fs.writeFile(destPath, src);
+    },
+
+    async saveScreenshot(destPath) {
+        const pngData = await driver.takeScreenshot();
+        const buf = Buffer.from(pngData, 'base64');
+        await fs.writeFile(destPath, buf);
+    },
+
+    async saveSnapshot(destPathBase) {
+        destPathBase = destPathBase || 'last-failed-e2e-test';
+        const currentUrl = await driver.getCurrentUrl();
+        const info = `URL: ${currentUrl}`;
+        await fs.writeFile(destPathBase + '.info', info);
+        await this.saveSource(destPathBase + '.html');
+        await this.saveScreenshot(destPathBase + '.png');
+    },
+
+    async sleep(ms) {
+        await driver.sleep(ms);
+    }
+}, ...extras);

server/test/e2e/lib/web.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const config = require('./config');
+const By = require('selenium-webdriver').By;
+const url = require('url');
+const UrlPattern = require('url-pattern');
+const driver = require('./mocha-e2e').driver;
+const page = require('./page');
+
+module.exports = (...extras) => page({
+
+    async navigate(pathOrParams) {
+        let path;
+        if (typeof pathOrParams === 'string') {
+            path = pathOrParams;
+        } else {
+            const urlPattern = new UrlPattern(this.requestUrl || this.url);
+            path = urlPattern.stringify(pathOrParams);
+        }
+
+        const parsedUrl = url.parse(path);
+        let absolutePath;
+        if (parsedUrl.host) {
+            absolutePath = path;
+        } else {
+            absolutePath = config.baseUrl + path;
+        }
+
+        await driver.navigate().to(absolutePath);
+        await this.waitUntilVisible();
+    },
+
+    async ensureUrl(path) {
+        const desiredUrl = path || this.url;
+
+        if (desiredUrl) {
+            const currentUrl = url.parse(await driver.getCurrentUrl());
+            const urlPattern = new UrlPattern(desiredUrl);
+            const params = urlPattern.match(currentUrl.pathname);
+            if (!params || config.baseUrl !== `${currentUrl.protocol}//${currentUrl.host}`) {
+                throw new Error(`Unexpected URL. Expecting ${config.baseUrl}${this.url} got ${currentUrl.protocol}//${currentUrl.host}/${currentUrl.pathname}`);
+            }
+
+            this.params = params;
+        }
+    },
+
+    async submit() {
+        const submitButton = await this.getElement('submitButton');
+        await submitButton.click();
+    },
+
+    async waitForFlash() {
+        await this.waitUntilVisible('div.alert:not(.js-warning)');
+    },
+
+    async getFlash() {
+        const elem = await driver.findElement(By.css('div.alert:not(.js-warning)'));
+        return await elem.getText();
+    },
+
+    async clearFlash() {
+        await driver.executeScript(`
+            var elements = document.getElementsByClassName('alert');
+            while(elements.length > 0){
+                elements[0].parentNode.removeChild(elements[0]);
+            }
+        `);
+    },
+
+    async setValue(key, value) {
+        const elem = await this.getElement(key);
+        await elem.clear();
+        await elem.sendKeys(value);
+    }
+
+}, ...extras);

server/test/e2e/lib/worker-counter.js

@@ -0,0 +1,33 @@
+'use strict';
+
+class WorkerCounter {
+    constructor() {
+        this.counter = 0;
+    }
+
+    enter() {
+        this.counter++;
+    }
+
+    exit() {
+        this.counter--;
+    }
+
+    async waitForEmpty() {
+        const self = this;
+
+        function wait(resolve) {
+            if (self.counter === 0) {
+                resolve();
+            } else {
+                setTimeout(wait, 500, resolve);
+            }
+        }
+
+        return new Promise(resolve => {
+            setTimeout(wait, 500, resolve);
+        });
+    }
+}
+
+module.exports = WorkerCounter;