/** * Restricted copy constructor. * @param beanToCopy the bean to copy from, not null */ private Builder(GenericSecurityTrade beanToCopy) { this.info = beanToCopy.getInfo(); this.security = beanToCopy.getSecurity(); this.quantity = beanToCopy.getQuantity(); this.price = beanToCopy.getPrice(); }
@Override public GenericSecurityTrade createTrade(TradeInfo info, double quantity, double tradePrice, ReferenceData refData) { return new GenericSecurityTrade(info, this, quantity, tradePrice); }
public void test_of() { GenericSecurityTrade test = GenericSecurityTrade.of(TRADE_INFO, SECURITY, QUANTITY, PRICE); assertEquals(test.getInfo(), TRADE_INFO); assertEquals(test.getSecurity(), SECURITY); assertEquals(test.getQuantity(), QUANTITY); assertEquals(test.getPrice(), PRICE); assertEquals(test.getProduct(), SECURITY); assertEquals(test.getCurrency(), SECURITY.getCurrency()); assertEquals(test.getSecurityId(), SECURITY.getSecurityId()); assertEquals(test.withInfo(TRADE_INFO).getInfo(), TRADE_INFO); assertEquals(test.withQuantity(129).getQuantity(), 129d, 0d); assertEquals(test.withPrice(129).getPrice(), 129d, 0d); }
public void test_builder() { GenericSecurityTrade test = sut(); assertEquals(test.getInfo(), TRADE_INFO); assertEquals(test.getSecurity(), SECURITY); assertEquals(test.getQuantity(), QUANTITY); assertEquals(test.getPrice(), PRICE); assertEquals(test.getCurrency(), SECURITY.getCurrency()); assertEquals(test.getSecurityId(), SECURITY.getSecurityId()); }
@Override public PortfolioItemSummary summarize() { // AAPL x 200 String description = getSecurityId().getStandardId().getValue() + " x " + SummarizerUtils.value(getQuantity()); return SummarizerUtils.summary(this, ProductType.SECURITY, description, getCurrency()); }
static GenericSecurityTrade sut() { return GenericSecurityTrade.builder() .info(TRADE_INFO) .security(SECURITY) .quantity(QUANTITY) .price(PRICE) .build(); }
static SecurityQuantityTrade parseTrade(CsvRow row, TradeInfo info, TradeCsvInfoResolver resolver) { SecurityTrade trade = parseSecurityTrade(row, info, resolver); SecurityTrade base = resolver.completeTrade(row, trade); Optional<Double> tickSizeOpt = row.findValue(TICK_SIZE).map(str -> LoaderUtils.parseDouble(str)); Optional<Currency> currencyOpt = row.findValue(CURRENCY).map(str -> Currency.of(str)); Optional<Double> tickValueOpt = row.findValue(TICK_VALUE).map(str -> LoaderUtils.parseDouble(str)); double contractSize = row.findValue(CONTRACT_SIZE).map(str -> LoaderUtils.parseDouble(str)).orElse(1d); if (tickSizeOpt.isPresent() && currencyOpt.isPresent() && tickValueOpt.isPresent()) { SecurityPriceInfo priceInfo = SecurityPriceInfo.of(tickSizeOpt.get(), CurrencyAmount.of(currencyOpt.get(), tickValueOpt.get()), contractSize); GenericSecurity sec = GenericSecurity.of(SecurityInfo.of(base.getSecurityId(), priceInfo)); return GenericSecurityTrade.of(base.getInfo(), sec, base.getQuantity(), base.getPrice()); } return base; }
/** * Returns the security from the row. * <p> * This returns a successful result where the trade associated with the row * implements {@link GenericSecurityTrade}. * * @return the security from the row */ Result<Security> getSecurity() { CalculationTarget target = getTarget(); if (target instanceof SecurityTrade) { SecurityTrade secTrade = (SecurityTrade) target; Security security = results.getReferenceData().getValue(secTrade.getSecurityId()); return Result.success(security); } if (target instanceof GenericSecurityTrade) { GenericSecurityTrade secTrade = (GenericSecurityTrade) target; return Result.success(secTrade.getSecurity()); } if (target instanceof Trade) { return Result.failure(FailureReason.INVALID, "Trade does not contain a security"); } return Result.failure(FailureReason.INVALID, "Calculaton target is not a trade"); }
static GenericSecurityTrade sut2() { return GenericSecurityTrade.builder() .info(TradeInfo.empty()) .security(SECURITY2) .quantity(QUANTITY2) .price(PRICE2) .build(); }
public void test_resolveTarget() { GenericSecurity security = GenericSecurityTest.sut(); Trade test = sut().resolveTarget(ImmutableReferenceData.of(SECURITY_ID, security)); GenericSecurityTrade expected = GenericSecurityTrade.of(TRADE_INFO, security, QUANTITY, PRICE); assertEquals(test, expected); }
@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 3237038: // info return ((GenericSecurityTrade) bean).getInfo(); case 949122880: // security return ((GenericSecurityTrade) bean).getSecurity(); case -1285004149: // quantity return ((GenericSecurityTrade) bean).getQuantity(); case 106934601: // price return ((GenericSecurityTrade) bean).getPrice(); } return super.propertyGet(bean, propertyName, quiet); }
public void test_load_genericSecurity() { TradeCsvLoader test = TradeCsvLoader.standard(); ValueWithFailures<List<Trade>> trades = test.load(FILE); List<GenericSecurityTrade> filtered = trades.getValue().stream() .flatMap(filtering(GenericSecurityTrade.class)) .collect(toImmutableList()); assertEquals(filtered.size(), 1); GenericSecurityTrade expected1 = GenericSecurityTrade.builder() .info(TradeInfo.builder() .id(StandardId.of("OG", "123433")) .tradeDate(date(2017, 6, 1)) .settlementDate(date(2017, 6, 3)) .build()) .security( GenericSecurity.of( SecurityInfo.of( SecurityId.of("OG-Security", "AAPL"), SecurityPriceInfo.of(5, CurrencyAmount.of(USD, 0.01), 10)))) .quantity(12) .price(14.5) .build(); assertBeanEquals(expected1, filtered.get(0)); }
public void test_resolveTarget() { GenericSecurity security = GenericSecurity.of(SECURITY.getInfo()); Trade test = sut().resolveTarget(ImmutableReferenceData.of(SECURITY.getSecurityId(), security)); GenericSecurityTrade expected = GenericSecurityTrade.of(TRADE_INFO, security, 3000, 20); assertEquals(test, expected); }
@Override public GenericSecurityTrade withInfo(TradeInfo info) { return new GenericSecurityTrade(info, security, quantity, price); }
private static Trade trade() { SecurityInfo info = SecurityInfo.of(SecurityId.of("OG-Test", "1"), 20, CurrencyAmount.of(USD, 10)); GenericSecurity security = GenericSecurity.of(info); TradeInfo tradeInfo = TradeInfo.builder() .counterparty(StandardId.of("cpty", "a")) .build(); return GenericSecurityTrade.builder() .info(tradeInfo) .security(security) .quantity(123) .price(456) .build(); }
public void test_resolveTarget() { GenericSecurity security = GenericSecurity.of(SECURITY.getInfo()); Trade test = sut().resolveTarget(ImmutableReferenceData.of(SECURITY.getSecurityId(), security)); GenericSecurityTrade expected = GenericSecurityTrade.of(TRADE_INFO, security, 3000, 20); assertEquals(test, expected); }
@Override public GenericSecurityTrade withPrice(double price) { return new GenericSecurityTrade(info, security, quantity, price); }
public void test_of() { GenericSecurity test = sut(); assertEquals(test.getInfo(), INFO); assertEquals(test.getSecurityId(), INFO.getId()); assertEquals(test.getCurrency(), INFO.getPriceInfo().getCurrency()); assertEquals(test.getUnderlyingIds(), ImmutableSet.of()); assertEquals(test, GenericSecurity.of(INFO)); assertEquals(test.createProduct(ReferenceData.empty()), test); assertEquals( test.createTrade(TradeInfo.empty(), 1, 2, ReferenceData.empty()), GenericSecurityTrade.of(TradeInfo.empty(), GenericSecurity.of(INFO), 1, 2)); assertEquals( test.createPosition(PositionInfo.empty(), 1, ReferenceData.empty()), GenericSecurityPosition.ofNet(PositionInfo.empty(), GenericSecurity.of(INFO), 1)); assertEquals( test.createPosition(PositionInfo.empty(), 1, 2, ReferenceData.empty()), GenericSecurityPosition.ofLongShort(PositionInfo.empty(), GenericSecurity.of(INFO), 1, 2)); }
@Override public GenericSecurityTrade build() { return new GenericSecurityTrade( info, security, quantity, price); }
@Override public GenericSecurityTrade withQuantity(double quantity) { return new GenericSecurityTrade(info, security, quantity, price); }