src/Form.test.ts

   1 import { ComputedLine, Line } from './Line';
   2 import TaxReturn from './TaxReturn';
   3 import Form from './Form';
   4 import { InconsistencyError, NotFoundError } from './Errors';
   5
   6 test('add and get line', () => {
   7   const l = new ComputedLine<number>('1', () => 42);
   8
   9   class TestForm extends Form<TestForm['_lines']> {
  10     readonly name = 'Test Form';
  11
  12     protected readonly _lines = { '1': l };
  13   };
  14
  15   const f = new TestForm();
  16   expect(f.getLine('1')).toBe(l);
  17 });
  18
  19 test('get non-existent line', () => {
  20   class TestForm extends Form<TestForm['_lines']> {
  21     readonly name = 'Test';
  22     protected readonly _lines = {};
  23   };
  24
  25   const f = new TestForm();
  26   const fAsAny: Form<any> = f;
  27   expect(() => fAsAny.getLine('line')).toThrow(NotFoundError);
  28
  29   //TYPEERROR:
  30   //expect(() => f.getLine('line')).toThrow(NotFoundError);
  31 });
  32
  33 test('input', () => {
  34   interface TestInput {
  35     filingStatus: string;
  36     money: number;
  37   };
  38   class TestForm extends Form<any, TestInput> {
  39     readonly name = '1040';
  40
  41     protected readonly _lines = null;
  42   };
  43
  44   const f = new TestForm({ filingStatus: 'S', money: 100.0 });
  45   expect(f.getInput('filingStatus')).toBe('S');
  46 });
  47
  48 test('get value', () => {
  49   class TestForm extends Form<TestForm['_lines']> {
  50     readonly name = 'Form';
  51
  52     protected readonly _lines = {
  53       line: new ComputedLine<number>('line', () => 42),
  54     };
  55   };
  56
  57   const f = new TestForm();
  58   const tr = new TaxReturn(2019);
  59   expect(f.getValue(tr, 'line')).toBe(42);
  60
  61   //TYPEERROR:
  62   //let s: string = f.getValue(tr, 'line');
  63
  64   const fAsAny: Form<any> = f;
  65   expect(() => fAsAny.getValue(tr, 'other')).toThrow(NotFoundError);
  66   //TYPEERROR:
  67   //expect(() => f.getValue(tr, 'other')).toThrow(NotFoundError);
  68 });
  69
  70 /*
  71 abstract class Form2<L extends { [key: string]: Line<any> } , I> {
  72   abstract readonly name: string;
  73
  74   protected abstract readonly _lines: L;
  75   protected abstract readonly _input?: I;
  76
  77   getLine<K extends keyof L>(key: K): L[K] {
  78     return this._lines[key];
  79   }
  80
  81   getInput<K extends keyof I>(key: K): I[K] {
  82     return this._input[key];
  83   }
  84
  85   getValue<T, K extends keyof L>(tr: TaxReturn, key: K): T {
  86     const line = this.getLine(key);
  87     return line.value(tr);
  88   }
  89 };
  90
  91 class FormG extends Form2<FormG['_lines'], FormG['_input']> {
  92   readonly name = 'G';
  93
  94   protected readonly _lines = {
  95     x: new ComputedLine('moo', () => 42),
  96     z: new ComputedLine('moo', () => 36),
  97   };
  98   protected readonly _input = null;
  99
 100   private _moo = 42;
 101
 102   getLineImpl<T, K extends keyof T>(lines: T, k: K): T[K] {
 103     return lines[k];
 104   }
 105
 106   allLines(): FormG['_lines'] {
 107     return this._lines;
 108   }
 109
 110   LINE = k => this.getLineImpl(this._lines, k);
 111
 112   testLine<K extends keyof ReturnType<FormG['allLines']>>(k: K): any {
 113     return this.getLineImpl(this._lines, k);
 114   }
 115 }
 116
 117 test('testing', () => {
 118   const g = new FormG();
 119   let v = g.testLine('x'); //g.getLineImpl(g._lines, 'x');
 120   let v2 = g.getValue(null, 'z');
 121   throw new Error(`v = ${v2}`);
 122 });
 123 */