jiapu/tests/security-pages.test.js

const assert = require('assert');
const fs = require('fs');
const path = require('path');
const vm = require('vm');
const SecurityPages = require('../public/js/security-pages.js');

const securityPagePath = path.join(__dirname, '..', 'profile-security.html');
const securityPagesPath = path.join(__dirname, '..', 'public', 'js', 'security-pages.js');

function hash(value) {
  return `hashed:${value}`;
}

function loadSecurityPages(root) {
  const source = fs.readFileSync(securityPagesPath, 'utf8');
  const sandbox = {
    module: { exports: {} },
    exports: {},
    globalThis: root,
    window: root
  };

  vm.runInNewContext(source, sandbox, { filename: securityPagesPath });
  return sandbox.module.exports;
}

function createPageRoot(api) {
  const handlers = {};
  const document = {
    addEventListener(type, handler) {
      handlers[type] = handler;
    },
    querySelector(selector) {
      return selector === '[data-security-page]' ? {} : null;
    },
    querySelectorAll() {
      return [];
    }
  };

  return {
    document,
    handlers,
    GenealogyApi: { defaultClient: api },
    confirm: () => true,
    alert: () => {},
    location: { href: '' }
  };
}

function waitForAsyncAction() {
  return new Promise((resolve) => setImmediate(resolve));
}

async function run() {
  assert.deepStrictEqual(SecurityPages.buildPasswordChangeBody({
    oldPassword: '123456',
    newPassword: 'abcdef'
  }, hash), {
    oldPassword: 'hashed:123456',
    newPassword: 'hashed:abcdef'
  });

  assert.deepStrictEqual(SecurityPages.buildPhoneChangeBody({
    newPhone: ' 13900000000 ',
    smsCode: ' 123456 ',
    validToken: ' ticket '
  }), {
    newPhone: '13900000000',
    smsCode: '123456',
    validToken: 'ticket'
  });

  assert.strictEqual(SecurityPages.buildSmsLoginBody, undefined);
  assert.doesNotMatch(fs.readFileSync(securityPagePath, 'utf8'), /data-security-form="sms-login"/);

  assert.deepStrictEqual(SecurityPages.buildDeactivateBody({
    password: '123456',
    reason: ' 不再使用 '
  }, hash), {
    password: 'hashed:123456',
    reason: '不再使用'
  });

  assert.strictEqual(SecurityPages.isDangerConfirmed('确认注销'), true);
  assert.strictEqual(SecurityPages.isDangerConfirmed('注销'), false);

  const logoutRoot = createPageRoot({
    logout() {
      return Promise.reject(new Error('network'));
    }
  });
  const LogoutPages = loadSecurityPages(logoutRoot);
  LogoutPages.init();
  logoutRoot.handlers.click({
    target: {
      closest(selector) {
        return selector === '[data-security-logout]' ? this : null;
      }
    },
    preventDefault() {}
  });
  await waitForAsyncAction();
  assert.strictEqual(logoutRoot.location.href, 'index.html');

  const deactivateRoot = createPageRoot({
    deactivateAccount() {
      return Promise.resolve();
    }
  });
  const DeactivatePages = loadSecurityPages(deactivateRoot);
  const deactivateForm = {
    getAttribute(name) {
      return name === 'data-security-form' ? 'deactivate' : null;
    },
    querySelectorAll(selector) {
      if (selector !== '[name]') return [];
      return [
        { name: 'password', value: '123456' },
        { name: 'reason', value: '' },
        { name: 'confirmText', value: '确认注销' }
      ];
    },
    querySelector() {
      return null;
    }
  };
  DeactivatePages.init();
  deactivateRoot.handlers.submit({
    target: {
      closest(selector) {
        return selector === '[data-security-form]' ? deactivateForm : null;
      }
    },
    preventDefault() {}
  });
  await waitForAsyncAction();
  assert.strictEqual(deactivateRoot.location.href, 'index.html');

  console.log('security-pages tests passed');
}

run().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});