ln-accounting 10.0.8 → 10.0.9

package/test/fiat/test_get_coingecko_historic_rate.js

@@ -1,152 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {fail} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const method = require('./../../fiat/get_coingecko_historic_rate');
-
-const makeArgs = overrides => {
-  const args = {
-    date: new Date().toISOString(),
-    currency: 'BTC',
-    fiat: 'USD',
-    rates: {},
-    request: ({qs}, cbk) => api({qs}, cbk),
-  };
-
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
-
-  return args;
-};
-
-const api = ({qs}, cbk) => {
-  return cbk(null, null, {market_data: {current_price: {usd: 12.34}}});
-};
-
-const tests = [
-  {
-    args: makeArgs({currency: undefined}),
-    description: 'A currency is required',
-    error: [400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({currency: 'ETH'}),
-    description: 'Only BTC is supported as a currency',
-    error: [400, 'UnsupportedCurrencyForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({date: undefined}),
-    description: 'A date is required',
-    error: [400, 'ExpectedDateForCoingeckoRateLookup'],
-  },
-  {
-    args: makeArgs({fiat: undefined}),
-    description: 'A fiat type is required',
-    error: [400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({fiat: 'EUR'}),
-    description: 'Only USD is supported as a fiat type',
-    error: [400, 'UnsupportedFiatTypeForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({rates: undefined}),
-    description: 'A rates object is required',
-    error: [400, 'ExpectedKnownRatesForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({request: undefined}),
-    description: 'A request method is required',
-    error: [400, 'ExpectedRequestMethodForCoingeckoFiatRateLookup'],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk('err')}),
-    description: 'Errors returned from request',
-    error: [503, 'UnexpectedErrGettingCoingeckoPastRate', {err: 'err'}],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk()}),
-    description: 'A body is expected in response',
-    error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk(null, null, {})}),
-    description: 'Market data is expected in response',
-    error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
-  },
-  {
-    args: makeArgs({request: ({}, cbk) => cbk(null, null, {market_data: {}})}),
-    description: 'A current price is expected in market data',
-    error: [503, 'UnexpectedResponseInCoingeckoPastRateResponse'],
-  },
-  {
-    args: makeArgs({
-      request: ({}, cbk) => cbk(null, null, {
-        market_data: {current_price: {}},
-      }),
-    }),
-    description: 'A price is expected in response',
-    error: [503, 'ExpectedCoingeckoCurrentPriceForFiat'],
-  },
-  {
-    args: makeArgs({}),
-    description: 'Get coingecko historic rate',
-    expected: {cents: 1234},
-  },
-  {
-    args: makeArgs({
-      date: '2020-01-02T03:04:05.000Z',
-      rates: {'2020-01-02T12:00:00.000Z': 5678},
-      request: ({}, cbk) => fail('Expected cached rate to be used'),
-    }),
-    description: 'A known rate for the same day is used instead of a request',
-    expected: {cents: 5678},
-  },
-  {
-    args: makeArgs({
-      date: '2020-01-02T03:04:05.000Z',
-      rates: {'2020-01-01T03:04:05.000Z': 5678},
-    }),
-    description: 'A known rate for a different day is not used',
-    expected: {cents: 1234},
-  },
-  {
-    args: makeArgs({
-      date: '2020-01-02T03:04:05.000Z',
-      rates: {'2020-01-02T03:04:05.000Z': 0},
-    }),
-    description: 'A falsy known rate falls back to a request',
-    expected: {cents: 1234},
-  },
-  {
-    args: makeArgs({
-      date: '2020-01-02T03:04:05.000Z',
-      request: (args, cbk) => {
-        deepEqual(args, {
-          json: true,
-          qs: {date: '02-01-2020', localization: false},
-          timeout: 30000,
-          url: 'https://api.coingecko.com/api/v3/coins/bitcoin/history',
-        });
-
-        return api(args, cbk);
-      },
-    }),
-    description: 'Request is made with the expected arguments',
-    expected: {cents: 1234},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(method(args), error, 'Got expected error');
-    } else {
-      const res = await method(args);
-
-      deepEqual(res, expected, 'Got expected return value');
-    }
-
-    return;
-  });
-});

package/test/fiat/test_get_fiat_values.js

@@ -1,74 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const {getFiatValues} = require('./../../fiat/');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {},
-    description: 'Currency code is required',
-    error: [400, 'ExpectedCurrencyToGetFiatValues'],
-  },
-  {
-    args: {currency: 'BTC'},
-    description: 'Dates are required',
-    error: [400, 'ExpectedDatesToGetFiatValues'],
-  },
-  {
-    args: {currency: 'BTC', dates: [date]},
-    description: 'Fiat type is required',
-    error: [400, 'ExpectedFiatTypeToGetFiatValues'],
-  },
-  {
-    args: {currency: 'BTC', dates: [date], fiat: 'USD'},
-    description: 'Rate method or request function is required',
-    error: [400, 'ExpectedRateMethodOrRequestMethodToGetFiat'],
-  },
-  {
-    args: {
-      currency: 'BTC',
-      dates: [date],
-      fiat: 'USD',
-      rate: ({}, cbk) => cbk(['err']),
-    },
-    description: 'Rate method errors are passed back',
-    error: ['err'],
-  },
-  {
-    args: {
-      currency: 'BTC',
-      dates: [date],
-      fiat: 'USD',
-      rate: ({}, cbk) => cbk(null, {cents: 123456}),
-    },
-    description: 'Get historic fiat rates',
-    expected: {rates: [{date, cents: 123456}]},
-  },
-  {
-    args: {
-      currency: 'BTC',
-      dates: [date, date],
-      fiat: 'USD',
-      rate: ({}, cbk) => cbk(null, {cents: 123456}),
-    },
-    description: 'Get historic fiat rates when the rate is already got',
-    expected: {rates: [{date, cents: 123456}, {date, cents: 123456}]},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(getFiatValues(args), error, 'Got expected error');
-    } else {
-      const {rates} = await getFiatValues(args);
-
-      deepEqual(rates, expected.rates, 'Rates returned');
-    }
-
-    return;
-  });
-});

package/test/fiat/test_get_historic_rate.js

@@ -1,77 +0,0 @@
-const {equal} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const getHistoricRate = require('./../../fiat/get_historic_rate');
-
-const date = new Date().toISOString();
-
-const api = ({}, cbk) => {
-  return cbk(null, null, {market_data: {current_price: {usd: 12.34}}});
-};
-
-const makeArgs = overrides => {
-  const args = {
-    date: new Date().toISOString(),
-    currency: 'BTC',
-    fiat: 'USD',
-    rates: {},
-    request: ({qs}, cbk) => api({qs}, cbk),
-  };
-
-  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
-
-  return args;
-};
-
-const tests = [
-  {
-    args: makeArgs({currency: undefined}),
-    description: 'A currency code is required',
-    error: [400, 'ExpectedCurrencyToGetHistoricRate'],
-  },
-  {
-    args: makeArgs({date: undefined}),
-    description: 'A date is required',
-    error: [400, 'ExpectedDateToGetHistoricRate'],
-  },
-  {
-    args: makeArgs({fiat: undefined}),
-    description: 'A fiat type is required to get historic rate',
-    error: [400, 'ExpectedFiatToGetHistoricRate'],
-  },
-  {
-    args: makeArgs({rates: undefined}),
-    description: 'Past rates are required to get historic rate',
-    error: [400, 'ExpectedRatesToGetHistoricRate'],
-  },
-  {
-    args: makeArgs({request: undefined}),
-    description: 'A request function is required to get historic rate',
-    error: [400, 'ExpectedRequestFunctionToGetHistoricRate'],
-  },
-  {
-    args: makeArgs({provider: 'provider'}),
-    description: 'A known rate provider is required to get historic rate',
-    error: [400, 'ExpectedKnownRateProviderToGetHistoricRate'],
-  },
-  {
-    args: makeArgs({}),
-    description: 'Get historic fiat rates',
-    expected: {cents: 1234},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(getHistoricRate(args), error, 'Gote expected error');
-    } else {
-      const {cents} = await getHistoricRate(args);
-
-      equal(cents, expected.cents, 'Rate returned');
-    }
-
-    return;
-  });
-});

package/test/harmony/test_categorize_records.js

@@ -1,156 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const {categorizeRecords} = require('./../../harmony');
-
-const tests = [
-  {
-    args: {
-      records: [
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-19T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-20T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-      ],
-    },
-    description: 'Categorize records',
-    expected: {
-      payments: [
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-19T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-20T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-      ],
-      payments_csv: [
-        '"Amount","Asset","Date & Time","Fiat Amount","From ID","Network ID","Notes","To ID","Transaction ID","Type"',
-        '1,"BTC","2019-07-19T03:31:39.916Z",,"from_id","external_id","notes","to_id","id","spend"',
-        '1,"BTC","2019-07-20T03:31:39.916Z",,"from_id","external_id","notes","to_id","id","spend"',
-      ].join('\n'),
-    },
-  },  {
-    args: {
-      records: [
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-21T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-20T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-      ],
-    },
-    description: 'Categorize records out of order',
-    expected: {
-      payments: [
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-20T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-        {
-          amount: 1,
-          asset: 'BTC',
-          category: 'payments',
-          created_at: '2019-07-21T03:31:39.916Z',
-          external_id: 'external_id',
-          from_id: 'from_id',
-          id: 'id',
-          notes: 'notes',
-          to_id: 'to_id',
-          type: 'spend',
-        },
-      ],
-      payments_csv: [
-        '"Amount","Asset","Date & Time","Fiat Amount","From ID","Network ID","Notes","To ID","Transaction ID","Type"',
-        '1,"BTC","2019-07-20T03:31:39.916Z",,"from_id","external_id","notes","to_id","id","spend"',
-        '1,"BTC","2019-07-21T03:31:39.916Z",,"from_id","external_id","notes","to_id","id","spend"',
-      ].join('\n'),
-    },
-  },
-  {
-    args: {},
-    description: 'Records are required',
-    error: 'ExpectedRecordsArrayToCategorize',
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => categorizeRecords(args), new Error(error), 'Got error');
-    } else {
-      const categorized = categorizeRecords(args);
-
-      deepEqual(categorized.payments, expected.payments, 'Categorized');
-      equal(categorized.payments_csv, expected.payments_csv, 'Categorize csv');
-    }
-
-    return end();
-  });
-});

package/test/harmony/test_chain_fees_as_records.js

@@ -1,40 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {chainFeesAsRecords} = require('./../../harmony');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {
-      transactions: [{
-        created_at: date,
-        fee: 1,
-        id: 'id',
-        is_outgoing: true,
-      }]
-    },
-    description: 'Chain fees as records',
-    expected: {
-      records: [{
-        amount: -1,
-        category: 'chain_fees',
-        created_at: date,
-        id: 'id:fee',
-        notes: '[Chain Fee]',
-        type: 'fee:network',
-      }],
-    },
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const {records} = chainFeesAsRecords(args);
-
-    deepEqual(records, expected.records, 'Fees formatted as records');
-
-    return end();
-  });
-});

package/test/harmony/test_chain_receives_as_records.js

@@ -1,73 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const {chainReceivesAsRecords} = require('./../../harmony');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {
-      channel_transaction_ids: ['funding_tx'],
-      transactions: [
-        {
-          created_at: new Date().toISOString(),
-          id: 'funding_tx',
-          is_confirmed: true,
-          is_outgoing: true,
-          output_addresses: ['out_address'],
-          tokens: 1,
-        },
-        {
-          created_at: date,
-          id: 'id',
-          is_confirmed: true,
-          is_outgoing: false,
-          output_addresses: ['address'],
-          tokens: 1,
-        },
-      ]
-    },
-    description: 'Chain receives as records',
-    expected: {
-      records: [{
-        amount: 1,
-        category: 'chain_receives',
-        created_at: date,
-        id: 'id',
-        notes: 'Outputs to address',
-        type: 'transfer:deposit',
-      }],
-    },
-  },
-  {
-    args: null,
-    description: 'Arguments expected',
-    error: 'ExpectedArgumentsToMapReceiveRecords',
-  },
-  {
-    args: {},
-    description: 'Channel transaction ids array expected',
-    error: 'ExpectedChannelTransactionIdsArrayToMapReceiveRecords',
-  },
-  {
-    args: {channel_transaction_ids: []},
-    description: 'Transaction info array expected',
-    error: 'ExpectedTransactionsArrayToMapToReceiveRecords',
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => chainReceivesAsRecords(args), new Error(error), 'Got err');
-    } else {
-      const {records} = chainReceivesAsRecords(args);
-
-      deepEqual(records, expected.records, 'Fees formatted as records');
-    }
-
-    return end();
-  });
-});

package/test/harmony/test_chain_sends_as_records.js

@@ -1,55 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {chainSendsAsRecords} = require('./../../harmony');
-
-const date = new Date().toISOString();
-
-const tests = [
-  {
-    args: {
-      channel_transaction_ids: ['funding_tx'],
-      transactions: [
-        {
-          created_at: new Date().toISOString(),
-          fee: 1,
-          id: 'funding_tx',
-          is_confirmed: true,
-          is_outgoing: true,
-          output_addresses: ['out_address'],
-          tokens: 2,
-        },
-        {
-          created_at: date,
-          fee: 1,
-          id: 'id',
-          is_confirmed: true,
-          is_outgoing: true,
-          output_addresses: ['address'],
-          tokens: 2,
-        },
-      ]
-    },
-    description: 'Chain sends as records',
-    expected: {
-      records: [{
-        amount: -1,
-        category: 'chain_sends',
-        created_at: date,
-        id: 'id',
-        notes: 'Outputs to address',
-        type: 'transfer:withdraw',
-      }],
-    },
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const {records} = chainSendsAsRecords(args);
-
-    deepEqual(records, expected.records, 'Fees formatted as records');
-
-    return end();
-  });
-});

package/test/harmony/test_formatted_notes.js

@@ -1,32 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const formattedNotes = require('./../../harmony/formatted_notes');
-
-const tests = [
-  {
-    args: {notes: 'notes'},
-    description: 'Notes formatted',
-    expected: {notes: 'notes'},
-  },
-  {
-    args: {notes: ''},
-    description: 'Empty notes formatted',
-    expected: {notes: ''},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    if (!!error) {
-      throws(() => formattedNotes(args), new Error(error), 'Got error');
-    } else {
-      const {notes} = formattedNotes(args);
-
-      equal(notes, expected.notes, 'Got formatted notes');
-    }
-
-    return end();
-  });
-});