@tasenor/common-node 1.9.16

package/src/testing/ProcessingSystemMock.ts

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { ID, ProcessConfig, ProcessName } from '@dataplug/tasenor-common'
+import { UnitTestImportConnector } from './UnitTestImportConnector'
+import { KnexDatabase, Process, ProcessConnector, ProcessFile, ProcessFileData, ProcessHandler, ProcessHandlerMap, ProcessStep } from '..'
+
+/**
+ * Processing system mock for unit testing.
+ */
+export class SystemMock {
+  db: KnexDatabase
+  handlers: ProcessHandlerMap = {}
+  connector: ProcessConnector
+  logger: {
+    info: (...msg) => void
+    error: (...msg) => void
+  }
+
+  constructor() {
+    this.connector = new UnitTestImportConnector()
+  }
+
+  async getTranslation(text: string, language: string): Promise<string> {
+    return this.connector.getTranslation(text, language)
+  }
+
+  register(handler: ProcessHandler): void {
+    //
+  }
+
+  async createProcess(name: ProcessName, filed: ProcessFileData[], config: ProcessConfig): Promise<Process> {
+    return new Process(this, name, config)
+  }
+
+  async checkFinishAndFindDirections(handler: ProcessHandler, step: ProcessStep): Promise<void> {
+    //
+  }
+
+  getHandler(name: string): ProcessHandler {
+    return this.handlers[name]
+  }
+
+  async loadProcess(id: ID): Promise<Process> {
+    return this.createProcess('dummy', [new ProcessFile({ name: 'file', encoding: 'utf-8', data: 'Hello' })], {})
+  }
+}

package/src/testing/UnitTestImportConnector.ts

@@ -0,0 +1,86 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { AccountAddress, AccountNumber, Asset, AssetExchange, AssetTransfer, AssetType, BalanceBookkeeping, Currency, Language, StockValueData, TradeableAsset, ImportState, ProcessConfig, Directions, ID } from '@dataplug/tasenor-common'
+import { ImportPlugin, TransactionImportConnector, TransactionImportHandler, ISPDemoServer } from '..'
+import { CoinbaseHandler } from '../../../tasenor-common-plugins/src/CoinbaseImport/backend/CoinbaseHandler'
+import IncomeAndExpenses from '../../../tasenor-common-plugins/src/IncomeAndExpenses/backend'
+
+/**
+ * A connector mock for unit testing.
+ */
+export class UnitTestImportConnector implements TransactionImportConnector {
+
+  private balance: Record<AccountNumber, number> = {}
+  private number: Record<AccountAddress, AccountNumber> = {}
+
+  async initialize(server: ISPDemoServer) {
+    //
+  }
+
+  addMoney(address: AccountAddress, number: AccountNumber, amount: number) {
+    this.balance[address] = (this.balance[address] || 0) + amount
+    this.number[address] = number
+  }
+
+  async initializeBalances(time: Date, balances: BalanceBookkeeping, config: ProcessConfig): Promise<void> {
+    balances.configureNames(config)
+    Object.keys(this.balance).forEach(address => balances.set(this.number[address], this.balance[address]))
+  }
+
+  async getAccountCanditates(): Promise<AccountNumber[]> {
+    return []
+  }
+
+  async getStock(time: Date, account: AccountNumber, symbol: TradeableAsset): Promise<StockValueData> {
+    return {
+      amount: 0,
+      value: 0
+    }
+  }
+
+  async getVAT(time: Date, transfer: AssetTransfer, currency: Currency): Promise<null | number> {
+    return null
+  }
+
+  async getRate(time: Date, type: AssetType, asset: Asset, currency: Currency, exchange: AssetExchange|null = null): Promise<number> {
+    return 1.0
+  }
+
+  async getTranslation(text: string, language: string): Promise<string> {
+    // Borrow a plugins to get some translations.
+    const plugin = new ImportPlugin(new CoinbaseHandler() as unknown as TransactionImportHandler)
+    const ret = plugin.t(text, language as Language)
+    if (ret !== text) {
+      return ret
+    }
+    const IEplugin = new IncomeAndExpenses()
+    return IEplugin.t(text, language as Language)
+  }
+
+  async applyResult(): Promise<Record<string, unknown>> {
+    return {}
+  }
+
+  async resultExists(processId: ID, args: unknown): Promise<boolean> {
+    return false
+  }
+
+  async success(res: ImportState) {
+    //
+  }
+
+  async fail(res: ImportState) {
+    //
+  }
+
+  async waiting(res: ImportState, directions: Directions) {
+    //
+  }
+
+  async run(): Promise<void> {
+    //
+  }
+
+  async rollback(processId: ID): Promise<boolean> {
+    return true
+  }
+}

package/src/testing/UnitTester.ts

@@ -0,0 +1,231 @@
+import { AccountAddress, AccountNumber, AdditionalTransferInfo, AssetTransfer, StockValueData, Transaction, TransactionDescription, TransactionLine, ImportStateText, ImportConfig } from '@dataplug/tasenor-common'
+import { TransactionImportHandler, AskUI, Process } from '..'
+import { getTestHandler } from './test-handlers'
+import { SystemMock } from './ProcessingSystemMock'
+import { sprintf } from 'sprintf-js'
+import { UnitTestImportConnector } from './UnitTestImportConnector'
+
+/**
+ * Helper types to reduce type forcing in simple test data.
+ */
+export type AssetTransferTestData = Omit<Omit<AssetTransfer, 'asset'>, 'amount'> & { asset: string, amount?: number | undefined | null }
+
+export type AdditionalTransferInfoTestData = Omit<AdditionalTransferInfo, 'stock'> & {
+  stock?: {
+    set?: Partial<Record<string, StockValueData>>
+    change?: Partial<Record<string, StockValueData>>
+  }
+}
+
+export type TransactionLineTestData = Omit<Omit<TransactionLine, 'data'>, 'account'> & {
+  account: string
+  data?: AdditionalTransferInfoTestData
+}
+
+/**
+ * A container for setting up testing system.
+ */
+export class UnitTester {
+
+  static accounts: string[] = [
+    'deposit.external.EUR',
+    'deposit.currency.EUR',
+    'expense.statement.TRADE_LOSS_STOCK',
+    'fee.currency.EUR',
+    'fee.currency.USD',
+    'income.statement.TRADE_PROFIT_CRYPTO',
+    'income.statement.TRADE_PROFIT_SHORT',
+    'trade.crypto.ETH',
+    'trade.currency.EUR',
+    'trade.currency.USD',
+    'trade.short.NAKD',
+    'trade.stock.NAKD',
+  ]
+
+  accountNumber: Record<string, string> = {}
+  accountName: Record<string, string> = {}
+  config: ImportConfig
+  handler: TransactionImportHandler
+  process: Process
+
+  constructor(conf: Record<string, unknown> = {}) {
+    this.config = {
+      currency: 'EUR',
+      language: 'en',
+      isTradeFeePartOfTotal: false,
+      allowShortSelling: false,
+      recordDeposits: true,
+      rules: []
+    }
+    Object.assign(this.config, conf)
+    let number = 1000
+    this.accountName = {}
+    this.accountNumber = {}
+    for (const name of UnitTester.accounts) {
+      this.config[`account.${name}`] = `${number}`
+      this.accountName[`${number}`] = name
+      this.accountNumber[name] = `${number}`
+      number += 10
+    }
+    this.handler = getTestHandler('Coinbase')
+    this.handler.system = new SystemMock()
+    this.process = new Process(this.handler.system, 'Unit test', this.config)
+  }
+
+  /**
+   * Set the configuration value. Also add mapping if account.
+   * @param name
+   * @param value
+   */
+  set(name, value) {
+    this.config[name] = value
+    if (name.startsWith('account.')) {
+      if (this.accountName[value]) {
+        throw new Error(`Account number ${value} already exists. Please choose some other for ${name}.`)
+      }
+      this.accountName[value] = name.substr(8)
+      this.accountNumber[name.substr(8)] = value
+    }
+  }
+
+  /**
+   * Add an answer to the answer collection.
+   */
+  answer(segment, name, value) {
+    this.config.answers = this.config.answers || {}
+    if (this.config.answers) {
+      this.config.answers[segment] = this.config.answers[segment] || {};
+      (this.config.answers[segment] as Record<string, unknown>)[name] = value
+    }
+  }
+
+  /**
+   * Get the account balance.
+   * @param name
+   */
+  get(addr): number {
+    const number = this.accountNumber[addr]
+    if (!number) {
+      throw new Error(`Invalid account name ${addr}.`)
+    }
+    return this.handler.getBalance(addr)
+  }
+
+  /**
+   * Add to the initial balance.
+   * @param accunt
+   * @param amount
+   */
+  addMoney(account: string, amount: number) {
+    if (!this.accountNumber[`${account}`]) {
+      throw new Error(`Account ${account} not defined in UnitTester class.`)
+    }
+    (this.handler.system.connector as UnitTestImportConnector).addMoney(account as AccountAddress, this.accountNumber[`${account}`] as AccountNumber, amount)
+  }
+
+  /**
+   * Construct a state for transfers.
+   * @param transfers
+   */
+  makeState(transferSets: AssetTransfer[][]): ImportStateText<'classified'> {
+    const state: ImportStateText<'classified'> = {
+      stage: 'classified',
+      files: {
+        'test.csv': {
+          lines: []
+        }
+      }
+    }
+
+    state.segments = {}
+    state.result = {}
+
+    for (let i = 0; i < transferSets.length; i++) {
+      const id = `segment${i}`
+      state.segments[id] = {
+        id,
+        time: new Date(`2022-01-01T00:00:${sprintf('%02d', i)}.000Z`),
+        lines: []
+      }
+      state.result[id] = [{
+        type: 'transfers',
+        transfers: transferSets[i]
+      }]
+    }
+
+    return state
+  }
+
+  /**
+   * Execute one or more transfer analysis.
+   * @param transfers
+   * @param entries
+   * @returns
+   */
+  async test(transfers: AssetTransferTestData[], entries: TransactionLineTestData[][],
+    transfers2: AssetTransferTestData[] | undefined = undefined, entries2: TransactionLineTestData[][] | undefined = undefined,
+    transfers3: AssetTransferTestData[] | undefined = undefined, entries3: TransactionLineTestData[][] | undefined = undefined,
+    transfers4: AssetTransferTestData[] | undefined = undefined, entries4: TransactionLineTestData[][] | undefined = undefined,
+    transfers5: AssetTransferTestData[] | undefined = undefined, entries5: TransactionLineTestData[][] | undefined = undefined
+  ) {
+    const transfersSets: AssetTransfer[][] = [transfers as AssetTransfer[]]
+    const entriesSet: TransactionLine[][][] = [entries as TransactionLine[][]]
+    if (transfers2) transfersSets.push(transfers2 as AssetTransfer[])
+    if (transfers3) transfersSets.push(transfers3 as AssetTransfer[])
+    if (transfers4) transfersSets.push(transfers4 as AssetTransfer[])
+    if (transfers5) transfersSets.push(transfers5 as AssetTransfer[])
+    if (entries2) entriesSet.push(entries2 as TransactionLine[][])
+    if (entries3) entriesSet.push(entries3 as TransactionLine[][])
+    if (entries4) entriesSet.push(entries4 as TransactionLine[][])
+    if (entries5) entriesSet.push(entries5 as TransactionLine[][])
+
+    const state = this.makeState(transfersSets)
+    // Check just for compiler.
+    if (!state.result || !state.segments) {
+      return
+    }
+
+    let out
+    try {
+      out = await this.handler.analysis(this.process, state, [], this.config)
+    } catch (err) {
+      if (err instanceof AskUI) {
+        console.log('\u001b[31mTest incomplete. Need more configuration.\u001b[0m')
+        console.dir(err.element, { depth: null })
+      }
+      throw err
+    }
+
+    if (!out.result) {
+      throw new Error(`Analyse failed to get results from ${JSON.stringify(state)}.`)
+    }
+
+    for (let i = 0; i < entriesSet.length; i++) {
+      const id = `segment${i}`
+      if (!out.result[id]) {
+        throw new Error(`Analyse failed to get results from ${JSON.stringify(state)}.`)
+      }
+      // Convert accounts to symbolic to make test writing easier.
+      for (const data of out.result[id] as TransactionDescription[]) {
+        if (data.transactions) {
+          for (const tx of data.transactions) {
+            for (const entry of tx.entries) {
+              if (this.accountName[entry.account]) {
+                entry.account = this.accountName[entry.account] as AccountNumber
+              }
+            }
+          }
+        }
+      }
+      // Verify results.
+      const result: Transaction[] = entriesSet[i].map(entries => ({
+        date: new Date(`2022-01-01T00:00:${sprintf('%02d', i)}.000Z`),
+        segmentId: id,
+        entries
+      }))
+
+      const { expect } = await import('@jest/globals')
+      expect(result).toStrictEqual(out.result[id][0].transactions)
+    }
+  }
+}

package/src/testing/index.ts

@@ -0,0 +1,4 @@
+export * from './ProcessingSystemMock'
+export * from './test-handlers'
+export * from './UnitTester'
+export * from './UnitTestImportConnector'

package/src/testing/test-handlers.ts

@@ -0,0 +1,55 @@
+import path from 'path'
+import { CoinbaseHandler } from '../../../tasenor-common-plugins/src/CoinbaseImport/backend/CoinbaseHandler'
+import { KrakenHandler } from '../../../tasenor-common-plugins/src/KrakenImport/backend/KrakenHandler'
+import { LynxHandler } from '../../../tasenor-common-plugins/src/LynxImport/backend/LynxHandler'
+import { NordeaHandler } from '../../../tasenor-common-plugins/src/NordeaImport/backend/NordeaHandler'
+import { NordnetHandler } from '../../../tasenor-common-plugins/src/NordnetImport/backend/NordnetHandler'
+import { TITOHandler } from '../../../tasenor-common-plugins/src/TITOImport/backend/TITOHandler'
+import { TransactionImportHandler } from '..'
+
+/**
+ * Mapping from handler class names to instances.
+ */
+const handlers: Record<string, TransactionImportHandler> = {
+  // Typescript commonly screws up, if there are slight version differencies. Force type.
+  Coinbase: new CoinbaseHandler() as unknown as TransactionImportHandler,
+  Nordea: new NordeaHandler() as unknown as TransactionImportHandler,
+  'Nordnet-Megalo': new NordnetHandler() as unknown as TransactionImportHandler,
+  'Nordnet-Hilunki': new NordnetHandler() as unknown as TransactionImportHandler,
+  Lynx: new LynxHandler() as unknown as TransactionImportHandler,
+  Kraken: new KrakenHandler() as unknown as TransactionImportHandler,
+  TITO: new TITOHandler() as unknown as TransactionImportHandler,
+}
+
+/**
+ * Get a handler instance for testing.
+ * @param name
+ * @returns
+ */
+export function getTestHandler(className: string): TransactionImportHandler {
+  if (!handlers[className]) {
+    throw new Error(`No such import handler as '${className}'.`)
+  }
+  return handlers[className]
+}
+
+/**
+ * Get handler path.
+ * @param className
+ * @returns
+ */
+export function getTestHandlerPath(className: string): string {
+  const handlerDirs: Record<string, string> = {
+    Coinbase: 'src/CoinbaseImport/backend',
+    Nordea: 'src/NordeaImport/backend',
+    'Nordnet-Megalo': 'src/NordnetImport/backend',
+    'Nordnet-Hilunki': 'src/NordnetImport/backend',
+    Lynx: 'src/LynxImport/backend',
+    Kraken: 'src/KrakenImport/backend',
+    TITO: 'src/TITOImport/backend',
+  }
+  if (!handlers[className]) {
+    throw new Error(`No such import handler path as '${className}'.`)
+  }
+  return path.join('../../tasenor-common-plugins', handlerDirs[className])
+}

package/tests/TransactionRules.spec.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from '@jest/globals'
+import { ImportSegment, ProcessConfig, TextFileLine } from '@dataplug/tasenor-common'
+import { TransactionImportHandler } from '../src/import/TransactionImportHandler'
+
+describe('TransactionRules', () => {
+
+  test('forming tags from object', async () => {
+    const now = new Date()
+    const handler = new TransactionImportHandler('Test')
+
+    const lines: TextFileLine[] = [
+      {
+        line: 0,
+        text: 'ABC',
+        columns: {
+          val: 'A'
+        }
+      }
+    ]
+
+    const segment: ImportSegment = {
+      id: 'ABCDE',
+      time: now,
+      lines: [
+        {
+          file: 'test.csv',
+          number: 0
+        }
+      ]
+    }
+
+    const config: ProcessConfig = {
+      currency: 'USD',
+      rules: [
+        {
+          name: 'Tag test',
+          filter: 'true',
+          result: [
+            {
+              reason: "'transfer'",
+              type: "'currency'",
+              asset: 'config.currency',
+              amount: '12',
+              tags: {
+                YES: 'true',
+                NO: 'false',
+                A: 'val=="A"',
+                B: 'val=="B"'
+              }
+            }
+          ]
+        }
+      ]
+    }
+
+    const result = await handler.classifyLines(lines, config, segment)
+
+    expect(result).toStrictEqual({
+      type: 'transfers',
+      transfers: [
+        {
+          reason: 'transfer',
+          type: 'currency',
+          asset: 'USD',
+          amount: 12,
+          tags: ['A', 'YES']
+        }
+      ]
+    })
+
+  })
+
+})

package/tests/TransferAnalyzer-account-address.spec.ts

@@ -0,0 +1,87 @@
+import { UnitTester } from '../src/testing'
+
+test('Direct expense account address', async () => {
+
+  const tester = new UnitTester()
+
+  await tester.test(
+    // Use direct reference to the account.
+    [
+      {
+        reason: 'expense',
+        type: 'account',
+        asset: '112233',
+        amount: -200,
+        data: {
+          text: 'My expense paid'
+        }
+      },
+      {
+        reason: 'expense',
+        type: 'account',
+        asset: '445566',
+        amount: 200
+      }
+    ], [[
+      {
+        account: '112233',
+        amount: -20000,
+        description: 'My expense paid',
+        data: {
+          text: 'My expense paid'
+        }
+      },
+      {
+        account: '445566',
+        amount: 20000,
+        description: 'My expense paid',
+      }
+    ]]
+  )
+})
+
+test('Direct income account address', async () => {
+
+  const tester = new UnitTester()
+
+  await tester.test(
+    // Use direct reference to the account.
+    [
+      {
+        reason: 'income',
+        type: 'account',
+        asset: '112233',
+        amount: -200,
+        data: {
+          text: 'My income paid.'
+        }
+      },
+      {
+        reason: 'income',
+        type: 'account',
+        asset: '445566',
+        amount: 200,
+        data: {
+          text: 'Yes it is.'
+        }
+      }
+    ], [[
+      {
+        account: '112233',
+        amount: -20000,
+        description: 'My income paid. Yes it is.',
+        data: {
+          text: 'My income paid.'
+        }
+      },
+      {
+        account: '445566',
+        amount: 20000,
+        description: 'My income paid. Yes it is.',
+        data: {
+          text: 'Yes it is.'
+        }
+      }
+    ]]
+  )
+})