lightning 9.14.0 → 10.0.0

package/test/lnd_gateway/test_gateway_subscribe.js

@@ -1,97 +0,0 @@
-const EventEmitter = require('events');
-const {equal} = require('node:assert').strict;
-const {once} = require('events');
-const test = require('node:test');
-
-const {encode} = require('cbor');
-
-const all = promise => Promise.all(promise);
-const gatewaySubscribe = require('./../../lnd_gateway/gateway_subscribe');
-
-const tests = [
-  {
-    args: {
-      bearer: 'bearer',
-      call: {
-        arguments: {},
-        method: 'method',
-        server: 'server',
-      },
-      url: 'http://url',
-    },
-    description: '',
-    expected: {
-      message: 'a4686d616361726f6f6e66626561726572666d6574686f64666d6574686f6466706172616d73f76673657276657266736572766572',
-      url: 'ws://url/',
-    },
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, () => {
-    return new Promise(async end => {
-      const emitter = new EventEmitter();
-
-      let message;
-
-      function websocket(url) {
-        equal(url, expected.url, 'Got expected url');
-
-        emitter.close = () => {};
-
-        emitter.send = n => {
-          if (Buffer.from(n).toString('hex') !== expected.message) {
-            throw new Error('GotUnexpectedMessageInWebSocket');
-          }
-
-          return end();
-        };
-
-        return emitter;
-      }
-
-      const eventEmitter = gatewaySubscribe({
-        websocket,
-        bearer: args.bearer,
-        call: args.call,
-        url: args.url,
-      });
-
-      emitter.emit('close');
-
-      const [gotErr] = await all([
-        new Promise((resolve, reject) => {
-          eventEmitter.on('error', err => resolve(err));
-        }),
-        new Promise((resolve, reject) => {
-          emitter.emit('error', new Error('Error'));
-
-          return resolve();
-        }),
-      ]);
-
-      equal(gotErr.toString(), 'Error: Error', 'Got error event');
-
-      const [gotMessage] = await all([
-        new Promise((resolve, reject) => {
-          eventEmitter.on('event', data => resolve(data));
-        }),
-        new Promise((resolve, reject) => {
-          emitter.emit('message', encode({event: 'event', data: 'data'}));
-
-          return resolve();
-        }),
-      ]);
-
-      equal(gotMessage, 'data', 'Got expected response');
-
-      emitter.emit('open');
-
-      emitter.emit('close');
-
-      eventEmitter.cancel();
-
-      return;
-    });
-  });
-});

package/test/lnd_gateway/test_grpc_response.js

@@ -1,29 +0,0 @@
-const test = require('node:test');
-
-const grpcResponse = require('./../../lnd_gateway/grpc_response');
-
-const tests = [
-  {
-    args: {credentials: {}},
-    description: 'Middleware attempts unauthenticated request',
-    expected: {},
-  },
-  {
-    args: {credentials: {socket: 'socket'}, locals: {auth: {bearer: '00'}}},
-    description: 'Middleware attempts authenticated socket request',
-    expected: {},
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const locals = args.locals || {};
-    const {middleware} = grpcResponse(args);
-
-    const res = {locals, send: () => {}, status: () => {}, type: () => {}};
-
-    middleware({params: {}}, res);
-
-    return end();
-  });
-});

package/test/lnd_gateway/test_grpc_router.js

@@ -1,20 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const {grpcRouter} = require('./../../');
-
-const tests = [
-  {
-    args: {},
-    description: 'A gRPC gateway router is returned',
-    expected: {type: 'function'},
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    equal(typeof grpcRouter({}), expected.type, 'Got expected result type');
-
-    return end();
-  });
-});

package/test/lnd_gateway/test_handle_errors.js

@@ -1,48 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const handleErrors = require('./../../lnd_gateway/handle_errors');
-
-const tests = [
-  {
-    args: {res: {headersSent: true}},
-    description: 'Headers already sent disables error handling',
-  },
-  {
-    args: {err: [501]},
-    description: 'Error code is returned',
-  },
-  {
-    args: {err: []},
-    description: 'Default error code is returned',
-  },
-  {
-    args: {err: new Error('err')},
-    description: 'Default error code is returned when the error is unknown',
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const {middleware} = handleErrors({});
-
-    const next = !!args.res && !!args.res.headersSent ? () => end() : null;
-
-    const res = {headersSent: args.res && !!args.res.headersSent};
-
-    if (!!args.err) {
-      const [expectedCode] = Array.isArray(args.err) ? args.err : [500];
-      let code;
-
-      res.status = n => code = n;
-
-      res.send = () => {
-        equal(code, expectedCode || 500, 'Got expected code');
-
-        return end();
-      };
-    }
-
-    return middleware(args.err, {}, res, next);
-  });
-});

package/test/lnd_gateway/test_lnd_gateway.js

@@ -1,67 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const websocket = require('ws');
-
-const {lndGateway} = require('./../../');
-
-const tests = [
-  {
-    args: {},
-    description: 'A request function is required',
-    error: 'ExpectedRequestMethodForLndGateway',
-  },
-  {
-    args: {request: () => {}},
-    description: 'A url endpoint is required',
-    error: 'ExpectedUrlForLndGateway',
-  },
-  {
-    args: {request: () => {}, url: 'url'},
-    description: 'A websocket constructor is required',
-    error: 'ExpectedWebSocketConstructorForLndGateway',
-  },
-  {
-    args: {websocket, request: (args, cbk) => cbk(args), url: 'url'},
-    description: 'A LND gateway is returned',
-    expected: {
-      err: [
-        503,
-        'UnexpectedErrorFromLndGatewayServer',
-        {
-          err: {
-            auth: {bearer: undefined},
-            body: Buffer.from('a0', 'hex'),
-            encoding: null,
-            forever: true,
-            headers: {'content-type': 'application/cbor'},
-            method: 'POST',
-            timeout: 25000,
-            uri: 'url/unlocker/genSeed',
-          },
-        },
-      ],
-    },
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => lndGateway(args), new Error(error), 'Got expected error');
-
-      return end();
-    } else {
-      const {lnd} = lndGateway(args);
-
-      lnd.unlocker.genSeed({}, (err, res) => {
-        const [code, message, details] = err;
-
-        deepStrictEqual(err, expected.err, 'Got expected result');
-
-        return end();
-      });
-    }
-  });
-});

package/test/lnd_gateway/test_return_response.js

@@ -1,51 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const returnResponse = require('./../../lnd_gateway/return_response');
-
-const tests = [
-  {
-    args: {err: true},
-    description: 'An error is returned',
-    expected: {code: 500},
-  },
-  {
-    args: {response: {err: 'err', res: 'res'}},
-    description: 'A response is returned',
-    expected: {
-      body: Buffer.from('a263657272636572726372657363726573', 'hex'),
-      type: 'application/cbor',
-    },
-  },
-  {
-    args: {response: {err: 'err', res: Symbol('foo')}},
-    description: 'Encoding errors return a server error',
-    expected: {code: 500},
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    let code;
-    let type;
-
-    const res = {
-      send: body => {
-        if (!!expected.code) {
-          equal(code, expected.code, 'Got expected code');
-        } else {
-          equal(type, expected.type, 'Got expected body type');
-          equal(body.equals(expected.body), true, 'Got expected body data');
-        }
-
-        return end();
-      },
-      status: n => code = n,
-      type: n => type = n,
-    };
-
-    returnResponse({res}).responder(args.err, args.response);
-
-    return;
-  });
-});

package/test/lnd_gateway/test_ws_url.js

@@ -1,32 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const wsUrl = require('./../../lnd_gateway/ws_url');
-
-const tests = [
-  {
-    args: {url: 'http://url'},
-    description: 'A plaintext protocol URL is converted to plaintext ws URL',
-    expected: {url: 'ws://url/'},
-  },
-  {
-    args: {url: 'https://url'},
-    description: 'An encrypted URL is converted to encrypted ws URL',
-    expected: {url: 'wss://url/'},
-  },
-  {
-    args: {url: 'ftp://url'},
-    description: 'An unrecognized scheme is kept the same',
-    expected: {url: 'ftp://url/'},
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const {url} = wsUrl(args);
-
-    equal(url, expected.url, 'Got expected websocket url');
-
-    return end();
-  });
-});

package/test/typescript/emit_grpc_events.test-d.ts

@@ -1,12 +0,0 @@
-import {expectType, expectError} from 'tsd';
-import WebSocket = require('ws');
-import {emitGrpcEvents} from '../../lnd_gateway';
-
-const ws = new WebSocket('address');
-
-expectError(emitGrpcEvents());
-expectError(emitGrpcEvents({}));
-expectType<void>(emitGrpcEvents({ws}));
-expectType<void>(emitGrpcEvents({cert: '00', ws}));
-expectType<void>(emitGrpcEvents({socket: 'socket', ws}));
-expectType<void>(emitGrpcEvents({cert: '00', socket: 'socket', ws}));

package/test/typescript/grpc_router.test-d.ts

@@ -1,8 +0,0 @@
-import {expectType} from 'tsd';
-import {Router} from 'express';
-import {grpcRouter} from '../../lnd_gateway';
-
-expectType<Router>(grpcRouter({}));
-expectType<Router>(grpcRouter({cert: '00'}));
-expectType<Router>(grpcRouter({socket: 'socket'}));
-expectType<Router>(grpcRouter({cert: '00', socket: 'socket'}));

package/test/typescript/lnd_gateway.test-d.ts

@@ -1,36 +0,0 @@
-import {expectType, expectError} from 'tsd';
-import request = require('request');
-import websocket = require('ws');
-import {UnauthenticatedLnd, AuthenticatedLnd} from '../../lnd_grpc';
-import {lndGateway} from '../../lnd_gateway';
-
-expectError(lndGateway());
-expectError(lndGateway({}));
-expectError(
-  lndGateway({
-    request,
-  })
-);
-expectError(lndGateway({request, url: 'url'}));
-expectType<{lnd: UnauthenticatedLnd}>(
-  lndGateway({request, url: 'url', websocket})
-);
-expectError<{lnd: AuthenticatedLnd}>(
-  lndGateway({request, url: 'url', websocket})
-);
-expectType<{lnd: AuthenticatedLnd}>(
-  lndGateway({
-    request,
-    url: 'url',
-    websocket,
-    macaroon: Buffer.alloc(1).toString('hex'),
-  })
-);
-expectError<{lnd: UnauthenticatedLnd}>(
-  lndGateway({
-    request,
-    url: 'url',
-    websocket,
-    macaroon: Buffer.alloc(1).toString('hex'),
-  })
-);