@barchart/portfolio-api-common 1.10.0 → 1.11.3

package/test/specs/data/TransactionValidatorSpec.js

@@ -1,94 +0,0 @@
-const Day = require('@barchart/common-js/lang/Day');
-
-const TransactionType = require('./../../../lib/data/TransactionType'),
-	TransactionValidator = require('./../../../lib/data/TransactionValidator');
-
-describe('When validating transaction order', () => {
-	'use strict';
-
-	const build = (sequence, day, type) => {
-		return { sequence: sequence, date: Day.parse(day), type: (type || TransactionType.BUY) };
-	};
-
-	it('An array of zero transactions should be valid', () => {
-		expect(TransactionValidator.validateOrder([])).toEqual(true);
-	});
-
-	it('An array of transactions with ordered sequences, on the same day should be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-04-30'), build(2, '2018-04-30'), build(3, '2018-04-30') ])).toEqual(true);
-	});
-
-	it('An array of transactions with ordered sequences, on the same day should be valid, where a dividend occurs last, should be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-04-30'), build(2, '2018-04-30', TransactionType.DIVIDEND) ])).toEqual(true);
-	});
-
-	it('An array of transactions with ordered sequences, on the same day should be valid, where a dividend occurs first, in strict mode, should not be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-04-30', TransactionType.DIVIDEND), build(2, '2018-04-30') ], true)).toEqual(false);
-	});
-
-	it('An array of transactions with ordered sequences, on the same day should be valid, where a dividend occurs first, in non-strict mode, should be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-04-30', TransactionType.DIVIDEND), build(2, '2018-04-30') ], false)).toEqual(true);
-	});
-
-	it('An array of transactions with ordered sequences, on the sequential days should be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-04-30'), build(2, '2018-05-01'), build(3, '2018-05-02', TransactionType.DIVIDEND) ])).toEqual(true);
-	});
-
-	it('An array of transactions with ordered sequences (starting after one), on the same day should not be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(3, '2018-04-30'), build(4, '2018-04-30'), build(5, '2018-04-30') ])).toEqual(false);
-	});
-
-	it('An array of transactions with duplicate sequences, on the same day should not be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-04-30'), build(1, '2018-04-30') ])).toEqual(false);
-	});
-
-	it('An array of transactions with with a gap in sequences, on the same day should not be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-04-30'), build(3, '2018-04-30') ])).toEqual(false);
-	});
-
-	it('An array of transactions with with a reversed sequences, on the same subsequent days should not be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(2, '2018-04-30'), build(1, '2018-05-01') ])).toEqual(false);
-	});
-
-	it('An array of transactions with ordered sequences, on the reversed days should not be valid', () => {
-		expect(TransactionValidator.validateOrder([ build(1, '2018-05-02'), build(2, '2018-05-01'), build(3, '2018-04-30') ])).toEqual(false);
-	});
-});
-
-describe('When validating transaction references', () => {
-	'use strict';
-
-	const build = (root, transaction) => {
-		return { reference: { root: root, transaction: transaction } };
-	};
-
-	it('An array of zero transactions should be valid', () => {
-		expect(TransactionValidator.validateReferences([])).toEqual(true);
-	});
-
-	it('An array with no references should be valid', () => {
-		expect(TransactionValidator.validateReferences([ { }, { } ])).toEqual(true);
-	});
-
-	it('An array with distinct references should be valid', () => {
-		expect(TransactionValidator.validateReferences([ build('a', 'x'), build('a', 'y'), build('b', 'y') ])).toEqual(true);
-	});
-
-	it('An array with non-distinct references should be not valid', () => {
-		expect(TransactionValidator.validateReferences([ build('a', 'x'), build('a', 'y'), build('b', 'x'), build('a', 'y') ])).toEqual(false);
-	});
-});
-
-describe('When requesting all the user-initiated transaction types', () => {
-	'use strict';
-
-	let userInitiated;
-
-	beforeEach(() => {
-		userInitiated = TransactionValidator.getUserInitiatedTransactionTypes();
-	});
-
-	it('Only nine types should be returned', () => {
-		expect(userInitiated.length).toEqual(9);
-	});
-});

package/test/specs/processing/PositionContainerSpec.js

@@ -1,185 +0,0 @@
-const Currency = require('@barchart/common-js/lang/Currency'),
-	Decimal = require('@barchart/common-js/lang/Decimal');
-
-const InstrumentType = require('./../../../lib/data/InstrumentType'),
-	PositionSummaryFrame = require('./../../../lib/data/PositionSummaryFrame');
-
-const PositionContainer = require('./../../../lib/processing/PositionContainer'),
-	PositionLevelDefinition = require('./../../../lib/processing/definitions/PositionLevelDefinition'),
-	PositionLevelType = require('./../../../lib/processing/definitions/PositionLevelType'),
-	PositionTreeDefinition = require('./../../../lib/processing/definitions/PositionTreeDefinition');
-
-describe('When a position container data is gathered', () => {
-	'use strict';
-
-	let positionCounter = 0;
-
-	function getPosition(portfolio, symbol, currency) {
-		return {
-			portfolio: portfolio,
-			position: (positionCounter++).toString(),
-			instrument: {
-				symbol: {
-					barchart: symbol
-				},
-				currency: currency || Currency.USD,
-				type: InstrumentType.EQUITY
-			},
-			snapshot: {
-				basis: new Decimal(123),
-				value: new Decimal(456),
-				open: new Decimal(1),
-				income: new Decimal(0),
-				gain: new Decimal(0),
-				buys: new Decimal(50),
-				sells: new Decimal(0)
-			}
-		};
-	}
-
-	function getSummaries(position, frame, count) {
-		const ranges = frame.getRecentRanges(count - 1);
-
-		return ranges.map((range) => {
-			return {
-				portfolio: position.portfolio,
-				position: position.position,
-				frame: frame,
-				start: {
-					date: range.start,
-					open: position.snapshot.open,
-					value: position.snapshot.value,
-					basis: position.snapshot.basis
-				},
-				end: {
-					date: range.end,
-					open: position.snapshot.open,
-					value: position.snapshot.value,
-					basis: position.snapshot.basis
-				},
-				period: {
-					buys: new Decimal(0),
-					sells: new Decimal(0),
-					income: new Decimal(0),
-					realized: new Decimal(0),
-					unrealized: new Decimal(0)
-				}
-			};
-		});
-	}
-
-	describe('for two portfolios, each with the same position, and the second portfolio with an addition position', () => {
-		let portfolios;
-		let positions;
-		let summaries;
-
-		beforeEach(() => {
-			portfolios = [
-				{
-					portfolio: 'My First Portfolio',
-					name: 'a'
-				}, {
-					portfolio: 'My Second Portfolio',
-					name: 'b'
-				}
-			];
-
-			positions = [
-				getPosition('My First Portfolio', 'AAPL'),
-				getPosition('My Second Portfolio', 'AAPL'),
-				getPosition('My Second Portfolio', 'TSLA')
-			];
-
-			summaries = positions.reduce((accumulator, position) => {
-				accumulator = accumulator.concat(getSummaries(position, PositionSummaryFrame.YTD, 1));
-				accumulator = accumulator.concat(getSummaries(position, PositionSummaryFrame.YEARLY, 3));
-
-				return accumulator;
-			}, [ ]);
-		});
-
-		describe('and a container is created grouping by total, portfolio, and instrument', () => {
-			let name;
-			let definitions;
-			let container;
-
-			beforeEach(() => {
-				definitions = [
-					new PositionTreeDefinition(name = 'the only tree', [
-						new PositionLevelDefinition('Total', PositionLevelType.OTHER, x => 'totals', x => 'Total', x => Currency.CAD),
-						new PositionLevelDefinition('Portfolio', PositionLevelType.PORTFOLIO, x => x.portfolio.portfolio, x => x.portfolio.name, x => Currency.CAD),
-						new PositionLevelDefinition('Position', PositionLevelType.POSITION, x => x.position.position, x => x.position.instrument.symbol.barchart, x =>  x.position.instrument.currency)
-					])
-				];
-
-				try {
-					container = new PositionContainer(definitions, portfolios, positions, summaries);
-				} catch (e) {
-					console.log(e);
-				}
-			});
-
-			it('the "Total" group should have two children groups', () => {
-				expect(container.getGroups(name, [ 'totals' ]).length).toEqual(2);
-			});
-
-			it('the "Total" group should have three items', () => {
-				expect(container.getGroup(name, [ 'totals' ]).items.length).toEqual(3);
-			});
-
-			it('The "a" portfolio group should have one child group', () => {
-				expect(container.getGroups(name, [ 'totals', 'My First Portfolio' ]).length).toEqual(1);
-			});
-
-			it('the "a" portfolio group should have one item', () => {
-				expect(container.getGroup(name, [ 'totals', 'My First Portfolio' ]).items.length).toEqual(1);
-			});
-
-			it('The "b" portfolio group should have two child groups', () => {
-				expect(container.getGroups(name, [ 'totals', 'My Second Portfolio' ]).length).toEqual(2);
-			});
-
-			it('the "b" portfolio group should have two items', () => {
-				expect(container.getGroup(name, [ 'totals', 'My Second Portfolio' ]).items.length).toEqual(2);
-			});
-
-			describe('and an item is pulled for one of the positions', function() {
-				let item;
-
-				let todayYear;
-				let todayMonth;
-				let todayDay;
-
-				beforeEach(() => {
-					item = container.getGroup(name, [ 'totals', 'My First Portfolio' ]).items[0];
-
-					const today = new Date();
-
-					todayYear = today.getFullYear();
-					todayMonth = today.getMonth() + 1;
-					todayDay = today.getDate();
-				});
-
-				it('the current summary should be a YTD summary for this year', () => {
-					expect(item.currentSummary).toBe(summaries.find(s => s.position === item.position.position && s.frame === PositionSummaryFrame.YTD && s.start.date.format() === `${(todayYear - 1)}-12-31` && s.end.date.format() === `${(todayYear - 0)}-12-31`));
-				});
-
-				it('should have two previous summaries', () => {
-					expect(item.previousSummaries.length).toEqual(3);
-				});
-
-				it('the previous (x1) summary should be a YEARLY summary for three years ago', () => {
-					expect(item.previousSummaries[0]).toBe(summaries.find(s => s.position === item.position.position && s.frame === PositionSummaryFrame.YEARLY && s.start.date.format() === `${(todayYear - 4)}-12-31` && s.end.date.format() === `${(todayYear - 3)}-12-31`));
-				});
-
-				it('the previous (x2) summary should be a YEARLY summary for the year before last', () => {
-					expect(item.previousSummaries[1]).toBe(summaries.find(s => s.position === item.position.position && s.frame === PositionSummaryFrame.YEARLY && s.start.date.format() === `${(todayYear - 3)}-12-31` && s.end.date.format() === `${(todayYear - 2)}-12-31`));
-				});
-
-				it('the previous (x3) summary should be a YEARLY summary for last year', () => {
-					expect(item.previousSummaries[2]).toBe(summaries.find(s => s.position === item.position.position && s.frame === PositionSummaryFrame.YEARLY && s.start.date.format() === `${(todayYear - 2)}-12-31` && s.end.date.format() === `${(todayYear - 1)}-12-31`));
-				});
-			});
-		});
-	});
-});

package/test/specs/serialization/PositionSchemaSpec.js

@@ -1,64 +0,0 @@
-const PositionSchema = require('./../../../lib/serialization/PositionSchema');
-
-describe('When positions are serialized', () => {
-	'use strict';
-
-	describe('for a read operation (user error #1)', () => {
-		let position;
-		let serialized;
-
-		beforeEach(() => {
-			position = {
-				"user": "855e15c0-9e32-40ac-9bd9-5f0cc2780111",
-				"portfolio": "c2a743e8-8efa-4a88-9a6c-9202d3fec29f",
-				"instrument": {
-					"id": "TGAM-CASH-USD",
-					"name": "US Dollar",
-					"type": "CASH",
-					"currency": "USD"
-				},
-				"position": "a5cdc2e8-d9c6-4a1f-8f05-e271a5824f87",
-				"transaction": 2987,
-				"cash": true,
-				"valuation": "AVG",
-				"snapshot": {
-					"date": "2020-06-11",
-					"open": "222105.56",
-					"direction": "LONG",
-					"buys": "0",
-					"sells": "0",
-					"gain": "0",
-					"basis": "0",
-					"income": "0",
-					"value": "0"
-				},
-				"system": {
-					"calculate": {
-						"processors": 1
-					},
-					"locked": false
-				}
-			};
-
-			serialized = JSON.stringify(position);
-		});
-
-		describe('and the data is deserialized', () => {
-			let deserialized;
-
-			beforeEach(() => {
-				const reviver = PositionSchema.CLIENT.schema.getReviver();
-
-				deserialized = JSON.parse(serialized, reviver);
-			});
-
-			it('the deserialized data should be an object', () => {
-				expect(typeof deserialized).toEqual('object');
-			});
-
-			it('the deserialized data should be correct', () => {
-				expect(deserialized.position).toEqual(position.position);
-			});
-		});
-	});
-});

package/test/specs/serialization/TransactionSchemaSpec.js

@@ -1,65 +0,0 @@
-const Day = require('@barchart/common-js/lang/Day'),
-	Decimal = require('@barchart/common-js/lang/Decimal');
-
-const TransactionType = require('./../../../lib/data/TransactionType');
-
-const TransactionSchema = require('./../../../lib/serialization/TransactionSchema');
-
-describe('When transactions are serialized', () => {
-	'use strict';
-
-	function transactionsAreEqual(a, b) {
-		expect(a.portfolio === b.portfolio).toEqual(true);
-		expect(a.position === b.position).toEqual(true);
-		expect(a.sequence === b.sequence).toEqual(true);
-		expect(a.type === b.type).toEqual(true);
-		expect(a.date.getIsEqual(b.date)).toEqual(true);
-		expect(a.price.getIsEqual(b.price)).toEqual(true);
-		expect(a.quantity.getIsEqual(b.quantity)).toEqual(true);
-		expect(a.fee.getIsEqual(b.fee)).toEqual(true);
-		expect(a.reinvest === b.reinvest).toEqual(true);
-		expect(a.cash === b.cash).toEqual(true);
-	}
-
-	describe('for an edit operation (user error #1)', () => {
-		let transaction;
-		let serialized;
-
-		beforeEach(() => {
-			transaction = { };
-
-			transaction.portfolio = '063e00ea-8d1b-4faa-aedf-f43bdf23590e';
-			transaction.position = 'c2eefcde-f8d0-438d-9414-28f307d7b544';
-			transaction.sequence = 1;
-			transaction.type = TransactionType.BUY;
-			transaction.date = new Day(2018, 7, 9);
-			transaction.price = new Decimal(15.92);
-			transaction.quantity = new Decimal(100);
-			transaction.fee = new Decimal(9.95);
-			transaction.reinvest = 'default';
-			transaction.cash = 'default';
-
-			const formatted = TransactionSchema.BUY.schema.format(transaction);
-
-			serialized = JSON.stringify(formatted);
-		});
-
-		it('the serialized data should be correct', () => {
-			expect(typeof serialized === 'string').toEqual(true);
-		});
-
-		describe('and the data is deserialized', () => {
-			let deserialized;
-
-			beforeEach(() => {
-				const reviver = TransactionSchema.BUY.schema.getReviver();
-
-				deserialized = JSON.parse(serialized, reviver);
-			});
-
-			it('the deserialized data should be correct', () => {
-				transactionsAreEqual(transaction, deserialized);
-			});
-		});
-	});
-});