alexa-cookie2 5.0.2 → 5.0.4

package/test/base-amazon-page-handle.test.js

@@ -0,0 +1,123 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+
+const testName = 'base-amazon-page-handle';
+const outputDir = process.env.ALEXA_COOKIE_TEST_OUTPUT_DIR || path.join(__dirname, '..', 'test-output');
+const outputFile = path.join(outputDir, `${testName}.txt`);
+const lines = [];
+
+function line(value = '') {
+    lines.push(value);
+}
+
+function writeOutput() {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(outputFile, `${lines.join('\n')}\n`);
+}
+
+function recordAssertion(description, fn) {
+    try {
+        fn();
+        line(`${description}: PASS`);
+    } catch (err) {
+        line(`${description}: FAIL`);
+        writeOutput();
+        throw err;
+    }
+}
+
+const cookieFile = path.join(__dirname, '..', 'alexa-cookie.js');
+const source = fs.readFileSync(cookieFile, 'utf8');
+
+let capturedProxyOptions;
+
+function loadCookieModule() {
+    capturedProxyOptions = undefined;
+    const module = { exports: {} };
+    const sandbox = {
+        __dirname: path.dirname(cookieFile),
+        console,
+        module,
+        exports: module.exports,
+        require(name) {
+            if (name === './lib/proxy.js') {
+                return {
+                    initAmazonProxy(options, _callbackCookie, callbackListening) {
+                        capturedProxyOptions = options;
+                        callbackListening && callbackListening({
+                            address: () => ({ port: options.proxyPort || 3456 }),
+                            close: (callback) => callback && callback()
+                        });
+                    }
+                };
+            }
+            if (name === 'cookie') {
+                return { parse: () => ({}) };
+            }
+            return require(name);
+        }
+    };
+    vm.runInNewContext(source, sandbox, { filename: cookieFile });
+    return module.exports;
+}
+
+function runProxyOnlyConfig(baseAmazonPage) {
+    const cookieModule = loadCookieModule();
+    const input = {
+        proxyOwnIp: '127.0.0.1',
+        proxyPort: 3456,
+        baseAmazonPage,
+        amazonPage: baseAmazonPage,
+        logger: () => {}
+    };
+    cookieModule.generateAlexaCookie('', '', input, () => {});
+    return { input, output: capturedProxyOptions };
+}
+
+try {
+    const de = runProxyOnlyConfig('amazon.de');
+    const uk = runProxyOnlyConfig('amazon.co.uk');
+    const com = runProxyOnlyConfig('amazon.com');
+
+    line('TEST: base Amazon page handle');
+    line('');
+    line('CODE UNDER TEST:');
+    line('- alexa-cookie.js: generateAlexaCookie option initialization');
+    line('- option passed to lib/proxy.js: baseAmazonPageHandle');
+    line('');
+    line('INPUT:');
+    line(`DE baseAmazonPage: ${de.input.baseAmazonPage}`);
+    line(`DE amazonPage: ${de.input.amazonPage}`);
+    line(`UK baseAmazonPage: ${uk.input.baseAmazonPage}`);
+    line(`UK amazonPage: ${uk.input.amazonPage}`);
+    line(`COM baseAmazonPage: ${com.input.baseAmazonPage}`);
+    line(`COM amazonPage: ${com.input.amazonPage}`);
+    line('');
+    line('OBSERVED:');
+    line(`DE baseAmazonPageHandle: ${de.output.baseAmazonPageHandle}`);
+    line(`UK baseAmazonPageHandle: ${uk.output.baseAmazonPageHandle}`);
+    line(`COM baseAmazonPageHandle: ${com.output.baseAmazonPageHandle}`);
+    line('');
+    line('ASSERTIONS:');
+    recordAssertion('DE baseAmazonPageHandle === "_de"', () => {
+        assert.strictEqual(de.output.baseAmazonPageHandle, '_de');
+    });
+    recordAssertion('UK baseAmazonPageHandle === "_uk"', () => {
+        assert.strictEqual(uk.output.baseAmazonPageHandle, '_uk');
+    });
+    recordAssertion('COM baseAmazonPageHandle === ""', () => {
+        assert.strictEqual(com.output.baseAmazonPageHandle, '');
+    });
+    line('');
+    line('RESULT: PASS');
+    writeOutput();
+} catch (err) {
+    if (!lines.includes('RESULT: PASS')) {
+        line('');
+        line('RESULT: FAIL');
+        writeOutput();
+    }
+    throw err;
+}

package/test/proxy-cookie-rewrite.test.js

@@ -0,0 +1,148 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vm = require('vm');
+
+const testName = 'proxy-cookie-rewrite';
+const outputDir = process.env.ALEXA_COOKIE_TEST_OUTPUT_DIR || path.join(__dirname, '..', 'test-output');
+const outputFile = path.join(outputDir, `${testName}.txt`);
+const lines = [];
+
+function line(value = '') {
+    lines.push(value);
+}
+
+function writeOutput() {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(outputFile, `${lines.join('\n')}\n`);
+}
+
+function recordAssertion(description, fn) {
+    try {
+        fn();
+        line(`${description}: PASS`);
+    } catch (err) {
+        line(`${description}: FAIL`);
+        writeOutput();
+        throw err;
+    }
+}
+
+const proxyFile = path.join(__dirname, '..', 'lib', 'proxy.js');
+const source = fs.readFileSync(proxyFile, 'utf8');
+
+let capturedProxyOptions;
+
+function createExpressStub() {
+    return {
+        use() {},
+        get() {},
+        listen() {
+            const server = {
+                address: () => ({ port: 3456 }),
+                on: () => server
+            };
+            return server;
+        }
+    };
+}
+
+function loadProxyModule() {
+    capturedProxyOptions = undefined;
+    const module = { exports: {} };
+    const sandbox = {
+        Buffer,
+        URL,
+        __dirname: path.dirname(proxyFile),
+        console,
+        module,
+        exports: module.exports,
+        require(name) {
+            if (name === 'express') return createExpressStub;
+            if (name === 'http-proxy-response-rewrite') return () => {};
+            if (name === 'http-proxy-middleware') {
+                return {
+                    createProxyMiddleware(_context, options) {
+                        capturedProxyOptions = options;
+                        return function proxyMiddleware() {};
+                    }
+                };
+            }
+            if (name === 'cookie') {
+                return { parse: () => ({}) };
+            }
+            return require(name);
+        }
+    };
+    vm.runInNewContext(source, sandbox, { filename: proxyFile });
+    return module.exports;
+}
+
+const proxyModule = loadProxyModule();
+const formerDataStorePath = path.join(os.tmpdir(), `alexa-cookie-proxy-cookie-test-${Date.now()}.json`);
+
+try {
+    const input = {
+        proxyOwnIp: '127.0.0.1',
+        proxyPort: 3456,
+        proxyListenBind: '0.0.0.0',
+        baseAmazonPage: 'amazon.de',
+        baseAmazonPageHandle: '_de',
+        amazonPageProxyLanguage: 'de_DE',
+        acceptLanguage: 'de-DE',
+        proxyLogLevel: 'silent',
+        formerDataStorePath
+    };
+    proxyModule.initAmazonProxy(input);
+    const cookieDomainRewrite = capturedProxyOptions.cookieDomainRewrite || {};
+    const cookiePathRewrite = capturedProxyOptions.cookiePathRewrite || {};
+    const cookieDomainRewriteKeys = Object.keys(cookieDomainRewrite);
+    const cookiePathRewriteKeys = Object.keys(cookiePathRewrite);
+
+    line('TEST: proxy cookie rewrite');
+    line('');
+    line('CODE UNDER TEST:');
+    line('- lib/proxy.js: cookieDomainRewrite');
+    line('- lib/proxy.js: cookiePathRewrite');
+    line('');
+    line('INPUT:');
+    line(`proxyOwnIp: ${input.proxyOwnIp}`);
+    line(`baseAmazonPage: ${input.baseAmazonPage}`);
+    line('');
+    line('OBSERVED:');
+    line(`cookieDomainRewrite keys: ${cookieDomainRewriteKeys.join(', ')}`);
+    line(`cookieDomainRewrite["*"]: ${cookieDomainRewrite['*']}`);
+    line(`cookiePathRewrite keys: ${cookiePathRewriteKeys.join(', ')}`);
+    line(`cookiePathRewrite["*"]: ${cookiePathRewrite['*']}`);
+    line(`cookieDomainRewrite contains proxy IP: ${Object.values(cookieDomainRewrite).includes(input.proxyOwnIp)}`);
+    line('');
+    line('ASSERTIONS:');
+    recordAssertion('cookieDomainRewrite only has "*" key', () => {
+        assert.deepStrictEqual(cookieDomainRewriteKeys, ['*']);
+    });
+    recordAssertion('cookieDomainRewrite["*"] === ""', () => {
+        assert.strictEqual(cookieDomainRewrite['*'], '');
+    });
+    recordAssertion('cookieDomainRewrite does not contain proxy IP', () => {
+        assert.ok(!Object.values(cookieDomainRewrite).includes(input.proxyOwnIp), 'set-cookie domain must not be rewritten to an IP address');
+    });
+    recordAssertion('cookiePathRewrite only has "*" key', () => {
+        assert.deepStrictEqual(cookiePathRewriteKeys, ['*']);
+    });
+    recordAssertion('cookiePathRewrite["*"] === "/"', () => {
+        assert.strictEqual(cookiePathRewrite['*'], '/');
+    });
+    line('');
+    line('RESULT: PASS');
+    writeOutput();
+} catch (err) {
+    if (!lines.includes('RESULT: PASS')) {
+        line('');
+        line('RESULT: FAIL');
+        writeOutput();
+    }
+    throw err;
+} finally {
+    fs.rmSync(formerDataStorePath, { force: true });
+}

package/test/proxy-cookie-sanitizing.test.js

@@ -0,0 +1,186 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vm = require('vm');
+
+const testName = 'proxy-cookie-sanitizing';
+const outputDir = process.env.ALEXA_COOKIE_TEST_OUTPUT_DIR || path.join(__dirname, '..', 'test-output');
+const outputFile = path.join(outputDir, `${testName}.txt`);
+const lines = [];
+
+function line(value = '') {
+    lines.push(value);
+}
+
+function writeOutput() {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(outputFile, `${lines.join('\n')}\n`);
+}
+
+function recordAssertion(description, fn) {
+    try {
+        fn();
+        line(`${description}: PASS`);
+    } catch (err) {
+        line(`${description}: FAIL`);
+        writeOutput();
+        throw err;
+    }
+}
+
+const proxyFile = path.join(__dirname, '..', 'lib', 'proxy.js');
+const source = fs.readFileSync(proxyFile, 'utf8');
+
+let capturedProxyOptions;
+
+function createExpressStub() {
+    return {
+        use() {},
+        get() {},
+        listen() {
+            const server = {
+                address: () => ({ port: 3456 }),
+                on: () => server
+            };
+            return server;
+        }
+    };
+}
+
+function loadProxyModule() {
+    capturedProxyOptions = undefined;
+    const module = { exports: {} };
+    const sandbox = {
+        Buffer,
+        URL,
+        __dirname: path.dirname(proxyFile),
+        console,
+        module,
+        exports: module.exports,
+        require(name) {
+            if (name === 'express') return createExpressStub;
+            if (name === 'http-proxy-response-rewrite') return () => {};
+            if (name === 'http-proxy-middleware') {
+                return {
+                    createProxyMiddleware(_context, options) {
+                        capturedProxyOptions = options;
+                        return function proxyMiddleware() {};
+                    }
+                };
+            }
+            return require(name);
+        }
+    };
+    vm.runInNewContext(source, sandbox, { filename: proxyFile });
+    return module.exports;
+}
+
+function createProxyRequest(cookie) {
+    const headers = {
+        cookie,
+        host: 'www.amazon.de',
+        origin: 'https://www.amazon.de'
+    };
+    return {
+        getHeader(name) {
+            return headers[name.toLowerCase()];
+        },
+        setHeader(name, value) {
+            headers[name.toLowerCase()] = value;
+        },
+        getHeaders() {
+            return headers;
+        }
+    };
+}
+
+function createProxyResponse(location) {
+    return {
+        statusCode: 302,
+        headers: {
+            location
+        },
+        socket: {
+            _host: 'www.amazon.de',
+            parser: {
+                outgoing: {
+                    method: 'GET',
+                    path: '/ap/maplanding?openid.oa2.authorization_code=AUTH_CODE_FROM_PROXY',
+                    getHeader() {
+                        return undefined;
+                    }
+                }
+            }
+        }
+    };
+}
+
+const proxyModule = loadProxyModule();
+const formerDataStorePath = path.join(os.tmpdir(), `alexa-cookie-proxy-cookie-sanitizing-test-${Date.now()}.json`);
+let callbackData;
+
+try {
+    const input = {
+        proxyOwnIp: '127.0.0.1',
+        proxyPort: 3456,
+        proxyListenBind: '0.0.0.0',
+        baseAmazonPage: 'amazon.de',
+        baseAmazonPageHandle: '_de',
+        amazonPageProxyLanguage: 'de_DE',
+        acceptLanguage: 'de-DE',
+        proxyLogLevel: 'silent',
+        formerDataStorePath
+    };
+    proxyModule.initAmazonProxy(input, (_err, data) => {
+        callbackData = data;
+    });
+
+    const proxyReq = createProxyRequest('connect.sid=LOCAL_BROWSER; session-id=SID_BROWSER; ubid-acbde=UBID_BROWSER');
+    const req = {
+        method: 'GET',
+        url: '/www.amazon.de/ap/maplanding?openid.oa2.authorization_code=AUTH_CODE_FROM_PROXY',
+        originalUrl: '/www.amazon.de/ap/maplanding?openid.oa2.authorization_code=AUTH_CODE_FROM_PROXY',
+        headers: {
+            host: '127.0.0.1:3456'
+        },
+        on() {}
+    };
+    capturedProxyOptions.onProxyReq(proxyReq, req);
+    capturedProxyOptions.onProxyRes(createProxyResponse('https://www.amazon.de/ap/maplanding?openid.oa2.authorization_code=AUTH_CODE_FROM_PROXY'), req, {});
+
+    line('TEST: proxy callback sanitizes login cookie');
+    line('');
+    line('CODE UNDER TEST:');
+    line('- lib/proxy.js: onProxyReq() proxy cookie capture');
+    line('- lib/proxy.js: callbackCookie loginCookie value');
+    line('');
+    line('OBSERVED:');
+    line(`loginCookie: ${callbackData && callbackData.loginCookie}`);
+    line('');
+    line('ASSERTIONS:');
+    recordAssertion('callback data is present', () => {
+        assert.ok(callbackData);
+    });
+    recordAssertion('loginCookie keeps Amazon session-id', () => {
+        assert.ok(callbackData.loginCookie.includes('session-id=SID_BROWSER'));
+    });
+    recordAssertion('loginCookie keeps Amazon ubid cookie', () => {
+        assert.ok(callbackData.loginCookie.includes('ubid-acbde=UBID_BROWSER'));
+    });
+    recordAssertion('loginCookie removes unrelated local browser cookie', () => {
+        assert.ok(!callbackData.loginCookie.includes('connect.sid=LOCAL_BROWSER'));
+    });
+    line('');
+    line('RESULT: PASS');
+    writeOutput();
+} catch (err) {
+    if (!lines.includes('RESULT: PASS')) {
+        line('');
+        line('RESULT: FAIL');
+        writeOutput();
+    }
+    throw err;
+} finally {
+    fs.rmSync(formerDataStorePath, { force: true });
+}

package/test/proxy-host-switch.test.js

@@ -0,0 +1,166 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vm = require('vm');
+
+const testName = 'proxy-host-switch';
+const outputDir = process.env.ALEXA_COOKIE_TEST_OUTPUT_DIR || path.join(__dirname, '..', 'test-output');
+const outputFile = path.join(outputDir, `${testName}.txt`);
+const lines = [];
+
+function line(value = '') {
+    lines.push(value);
+}
+
+function writeOutput() {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(outputFile, `${lines.join('\n')}\n`);
+}
+
+function recordAssertion(description, fn) {
+    try {
+        fn();
+        line(`${description}: PASS`);
+    } catch (err) {
+        line(`${description}: FAIL`);
+        writeOutput();
+        throw err;
+    }
+}
+
+const proxyFile = path.join(__dirname, '..', 'lib', 'proxy.js');
+const source = fs.readFileSync(proxyFile, 'utf8');
+
+let capturedProxyOptions;
+
+function createExpressStub() {
+    return {
+        use() {},
+        get() {},
+        listen() {
+            const server = {
+                address: () => ({ port: 3456 }),
+                on: () => server
+            };
+            return server;
+        }
+    };
+}
+
+function loadProxyModule() {
+    capturedProxyOptions = undefined;
+    const module = { exports: {} };
+    const sandbox = {
+        Buffer,
+        URL,
+        __dirname: path.dirname(proxyFile),
+        console,
+        module,
+        exports: module.exports,
+        require(name) {
+            if (name === 'express') return createExpressStub;
+            if (name === 'http-proxy-response-rewrite') return () => {};
+            if (name === 'http-proxy-middleware') {
+                return {
+                    createProxyMiddleware(_context, options) {
+                        capturedProxyOptions = options;
+                        return function proxyMiddleware() {};
+                    }
+                };
+            }
+            if (name === 'cookie') {
+                return { parse: () => ({}) };
+            }
+            return require(name);
+        }
+    };
+    vm.runInNewContext(source, sandbox, { filename: proxyFile });
+    return module.exports;
+}
+
+function applyPathRewrite(pathname, req) {
+    const rewrite = capturedProxyOptions.pathRewrite;
+    if (typeof rewrite === 'function') return rewrite(pathname, req);
+    for (const pattern of Object.keys(rewrite)) {
+        const regex = new RegExp(pattern);
+        if (regex.test(pathname)) return pathname.replace(regex, rewrite[pattern]);
+    }
+    return pathname;
+}
+
+const proxyModule = loadProxyModule();
+const formerDataStorePath = path.join(os.tmpdir(), `alexa-cookie-proxy-host-test-${Date.now()}.json`);
+
+try {
+    const input = {
+        proxyOwnIp: '127.0.0.1',
+        proxyPort: 3456,
+        proxyListenBind: '0.0.0.0',
+        baseAmazonPage: 'amazon.de',
+        baseAmazonPageHandle: '_de',
+        amazonPageProxyLanguage: 'de_DE',
+        acceptLanguage: 'de-DE',
+        proxyLogLevel: 'silent',
+        formerDataStorePath
+    };
+    proxyModule.initAmazonProxy(input);
+
+    const directReq = {
+        method: 'GET',
+        url: '/www.amazon.com/ap/signin',
+        headers: { host: '127.0.0.1:3456' }
+    };
+    const refererReq = {
+        method: 'POST',
+        url: '/ap/cvf/verify',
+        headers: {
+            host: '127.0.0.1:3456',
+            referer: 'http://127.0.0.1:3456/www.amazon.com/ap/signin'
+        }
+    };
+
+    const directTarget = capturedProxyOptions.router(directReq);
+    const directRewrittenPath = applyPathRewrite(directReq.url, directReq);
+    const refererTarget = capturedProxyOptions.router(refererReq);
+
+    line('TEST: proxy host switch');
+    line('');
+    line('CODE UNDER TEST:');
+    line('- lib/proxy.js: router()');
+    line('- lib/proxy.js: rewriteProxyPath()');
+    line('');
+    line('INPUT:');
+    line(`baseAmazonPage: ${input.baseAmazonPage}`);
+    line(`direct request url: ${directReq.url}`);
+    line(`referer request url: ${refererReq.url}`);
+    line(`referer header: ${refererReq.headers.referer}`);
+    line('');
+    line('OBSERVED:');
+    line(`direct router target: ${directTarget}`);
+    line(`direct rewritten path: ${directRewrittenPath}`);
+    line(`referer router target: ${refererTarget}`);
+    line('');
+    line('ASSERTIONS:');
+    recordAssertion('direct router target === "https://www.amazon.com"', () => {
+        assert.strictEqual(directTarget, 'https://www.amazon.com');
+    });
+    recordAssertion('direct rewritten path === "/ap/signin"', () => {
+        assert.strictEqual(directRewrittenPath, '/ap/signin');
+    });
+    recordAssertion('referer router target === "https://www.amazon.com"', () => {
+        assert.strictEqual(refererTarget, 'https://www.amazon.com');
+    });
+    line('');
+    line('RESULT: PASS');
+    writeOutput();
+} catch (err) {
+    if (!lines.includes('RESULT: PASS')) {
+        line('');
+        line('RESULT: FAIL');
+        writeOutput();
+    }
+    throw err;
+} finally {
+    fs.rmSync(formerDataStorePath, { force: true });
+}