paid-services/test/server/test_paid_service_event.js

Lightning Paid Services library

const {deepStrictEqual, rejects} = require('node:assert/strict');
const {before, test} = require('node:test');

const {encodeTlvStream} = require('bolt01');
const {makeInvoice} = require('mock-lnd');
const {makeLnd} = require('mock-lnd');
const {makePayViaRoutesResponse} = require('mock-lnd');
const {makePaymentRequest} = require('mock-lnd');
const tinysecp = require('tiny-secp256k1');

const messagesForRequest = require('./../../client/messages_for_request');
const method = require('./../../server/paid_service_event');

const encode = records => encodeTlvStream({records: [records]}).encoded;
const id1 = Buffer.alloc(32).toString('hex');
const id2 = Buffer.alloc(32, 1).toString('hex');

let messages;
let request;

before(async () => {
  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);

  ({request} = makePaymentRequest({ecp}));
  ({messages} = messagesForRequest({reply: request, service: '2'}));
});

const makeArgs = overrides => {
  let requests = 0;

  const lnd = makeLnd({
    getInvoice: ({}, cbk) => {
      return cbk(null, makeInvoice({
        is_confirmed: true,
        is_push: true,
        payments: [{messages, is_confirmed: true}],
      }));
    },
    payViaRoutes: ({}, cbk) => {
      requests++;

      if (requests === 2) {
        return cbk(null, makePayViaRoutesResponse({}));
      }

      return cbk(null, makePayViaRoutesResponse({is_unknown_failure: true}));
    },
  });

  const args = {
    lnd,
    env: {},
    fetch: () => new Promise(resolve => resolve()),
    id: id1,
    network: 'btc',
    payer: lnd,
  };

  Object.keys(overrides).forEach(k => args[k] = overrides[k]);

  return args;
};

const tests = [
  {
    args: () => makeArgs({env: undefined}),
    description: 'Processing a service request requires env vars',
    error: [400, 'ExpectedEnvironmentVariablesForPaidServiceEvent'],
  },
  {
    args: () => makeArgs({fetch: undefined}),
    description: 'Processing a service request requires a fetch function',
    error: [400, 'ExpectedFetchFunctionForPaidServiceEvent'],
  },
  {
    args: () => makeArgs({id: undefined}),
    description: 'Processing a service request requires an invoice id',
    error: [400, 'ExpectedInvoiceIdForPaidServiceEvent'],
  },
  {
    args: () => makeArgs({lnd: undefined}),
    description: 'Processing a service request requires lnd to lookup invoice',
    error: [400, 'ExpectedAuthenticatedLndForPaidServiceEvent'],
  },
  {
    args: () => makeArgs({network: undefined}),
    description: 'Processing a service request requires network name',
    error: [400, 'ExpectedNetworkNameStringToGetServiceRequest'],
  },
  {
    args: () => makeArgs({payer: undefined}),
    description: 'Processing a service request requires a payer to respond',
    error: [400, 'ExpectedPayerLndForPaidServiceEvent'],
  },
  {
    args: () => makeArgs({}),
    description: 'A paid service event happens',
    expected: {
      error: undefined,
      node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
      service: 'ping',
    },
  },
  {
    args: () => makeArgs({
      lnd: makeLnd({
        getInvoice: ({}, cbk) => {
          return cbk(null, makeInvoice({
            is_confirmed: true,
            is_push: true,
            payments: [],
          }));
        },
      }),
    }),
    description: 'A random push happens',
    expected: {},
  },
  {
    args: () => makeArgs({
      env: {
        PAID_SERVICES_INBOX_EMAIL_FROM: 'from',
        PAID_SERVICES_INBOX_EMAIL_TO: 'to',
        PAID_SERVICES_INBOX_POSTMARK_API_KEY: 'key',
        PAID_SERVICES_INBOX_PRICE: '1',
      },
      lnd: makeLnd({
        getInvoice: ({id}, cbk) => {
          switch (id) {
          case id1:
            return cbk(null, makeInvoice({
              description_hash: id2,
              is_confirmed: true,
            }));

          case id2:
            return cbk(null, makeInvoice({
              is_confirmed: true,
              is_push: true,
              payments: [{
                is_confirmed: true,
                messages: messagesForRequest({
                  arguments: encode({
                    type: '0',
                    value: Buffer.from('message').toString('hex'),
                  }),
                  reply: request,
                  service: '4',
                }).messages,
              }],
            }));

          default:
            return cbk([500, 'UnexpectedIdentifierForGetInvoice', {id}]);
          }
        },
      }),
    }),
    description: 'A paywall request is processed',
    expected: {
      error: undefined,
      node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
      service: 'inbox',
    },
  },
  {
    args: () => makeArgs({
      lnd: makeLnd({
        getInvoice: ({}, cbk) => {
          return cbk(null, makeInvoice({
            is_confirmed: true,
            is_push: true,
            payments: [{
              messages: messagesForRequest({
                reply: request,
                service: '3',
              }).messages,
              is_confirmed: true,
            }],
          }));
        },
      }),
    }),
    description: 'A request is processed',
    expected: {
      error: [404, 'ServiceCurrentlyUnsupported'],
      node: '03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad',
      service: 'profile',
    },
  },
];

tests.forEach(({args, description, error, expected}) => {
  test(description, async () => {
    if (!!error) {
      await rejects(
        method(args()),
        err => {
          deepStrictEqual(err, error, 'Got expected error');

          return true;
        },
        'Got expected error'
      );
    } else {
      const res = await method(args());

      deepStrictEqual(res, expected, 'Got expected result');
    }
  });
});