paid-services/test/respond/test_send_service_response.js

Lightning Paid Services library

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

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

const method = require('./../../respond/send_service_response');

let ecp;

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

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

  const lnd = makeLnd({
    payViaRoutes: ({}, cbk) => {
      requests++;

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

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

  const args = {
    lnd,
    mtokens: '10000',
    request: 'lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d73gafnh3cax9rn449d9p5uxz9ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ecky03ylcqca784w',
    text: 'text',
  };

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

  return args;
};

const tests = [
  {
    args: () => makeArgs({error: 'error'}),
    description: 'A request is expected to include valid response records',
    error: [400, 'ExpectedValidServiceResponseToSend'],
  },
  {
    args: () => makeArgs({mtokens: undefined}),
    description: 'The mtokens received are expected',
    error: [400, 'ExpectedMillitokensReceivedToSendResponse'],
  },
  {
    args: () => makeArgs({request: undefined}),
    description: 'A response request is expected',
    error: [400, 'ExpectedResponsePaymentRequestToSendResponse'],
  },
  {
    args: () => makeArgs({request: 'request'}),
    description: 'A valid response request is expected',
    error: [400, 'ExpectedValidPaymentRequestToPayResponse'],
  },
  {
    args: () => makeArgs({}),
    description: 'An unexpired invoice is required',
    error: [400, 'ExpectedUnexpiredInvoiceToSendServiceResponse'],
  },
  {
    args: () => makeArgs({
      mtokens: '1',
      request: makePaymentRequest({ecp}).request,
    }),
    description: 'Payment cannot be greater than the mtokens received',
    error: [400, 'ExpectedPaymentTokensNotGreaterThanReceived'],
  },
  {
    args: () => makeArgs({
      request: makePaymentRequest({ecp, mtokens: '0'}).request,
    }),
    description: 'A zero mtokens response is paid',
  },
  {
    args: () => makeArgs({
      request: makePaymentRequest({ecp, mtokens: '1'}).request,
    }),
    description: 'A service response is delivered',
  },
];

tests.forEach(({args, description, error, expected}) => {
  test(description, async () => {
    if (!!error) {
      await rejects(
        method(args()),
        err => {
          const [code, message] = err;

          deepStrictEqual([code, message], error, 'Got error');

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

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