@Test
public void testIndexWhenNoQuotesExist() {
DateMidnight startDate = new DateMidnight(2012, 12, 31);
DateMidnight endDate = new DateMidnight(2013, 3, 31);
// create model
Client client = new Client();
Account account = new Account();
client.addAccount(account);
addT(
account,
startDate.toCalendar(Locale.getDefault()),
Type.DEPOSIT,
100 * Values.Amount.factor());
Security security = new Security();
client.addSecurity(security);
// calculate performance indices
List<Exception> warnings = new ArrayList<Exception>();
ReportingPeriod reportInterval =
new ReportingPeriod.FromXtoY(startDate.toDate(), endDate.toDate());
ClientIndex clientIndex = PerformanceIndex.forClient(client, reportInterval, warnings);
PerformanceIndex securityIndex = PerformanceIndex.forSecurity(clientIndex, security, warnings);
// asserts
assertTrue(warnings.isEmpty());
assertThat(securityIndex.getDates().length, is(1));
assertThat(securityIndex.getDates()[0], is(clientIndex.getFirstDataPoint().toDate()));
}
@Before
public void setupClient() {
client = new Client();
account = new Account();
client.addAccount(account);
portfolio = new Portfolio();
client.addPortfolio(portfolio);
security = new Security();
client.addSecurity(security);
}
@Test
public void testThatSecurityIndexIsCalculated() {
DateMidnight startDate = new DateMidnight(2012, 12, 31);
DateMidnight endDate = new DateMidnight(2013, 4, 1);
long startPrice = 100 * Values.Amount.factor();
// create model
Client client = new Client();
Account account = new Account();
client.addAccount(account);
addT(account, startDate.toCalendar(Locale.getDefault()), Type.DEPOSIT, startPrice);
Security security = new Security();
client.addSecurity(security);
generatePrices(security, startPrice, startDate, endDate);
// calculate performance indices
List<Exception> warnings = new ArrayList<Exception>();
ReportingPeriod reportInterval =
new ReportingPeriod.FromXtoY(startDate.toDate(), endDate.toDate());
ClientIndex clientIndex = PerformanceIndex.forClient(client, reportInterval, warnings);
PerformanceIndex securityIndex = PerformanceIndex.forSecurity(clientIndex, security, warnings);
// asserts
assertTrue(warnings.isEmpty());
Date[] dates = securityIndex.getDates();
assertThat(dates[0], is(startDate.toDate()));
assertThat(dates[dates.length - 1], is(endDate.toDate()));
long lastPrice = security.getSecurityPrice(endDate.toDate()).getValue();
double performance = (double) (lastPrice - startPrice) / (double) startPrice;
double[] accumulated = securityIndex.getAccumulatedPercentage();
assertThat(accumulated[0], is(0d));
assertThat(accumulated[accumulated.length - 1], IsCloseTo.closeTo(performance, 0.000001d));
}
@Test
public void testThatNotTheSameAccountIsMatched() {
Account second = new Account();
client.addAccount(second);
account.addTransaction(
new AccountTransaction(
Dates.today(),
security, //
AccountTransaction.Type.TRANSFER_IN,
2));
AccountTransaction umatched =
new AccountTransaction(
Dates.today(),
security, //
AccountTransaction.Type.TRANSFER_OUT,
2);
account.addTransaction(umatched);
second.addTransaction(
new AccountTransaction(
Dates.today(),
security, //
AccountTransaction.Type.TRANSFER_OUT,
2));
List<Issue> issues = new CrossEntryCheck().execute(client);
assertThat(issues.size(), is(1));
assertThat(issues.get(0), is(MissingAccountTransferIssue.class));
assertThat(account.getTransactions(), hasItem(umatched));
assertThat(second.getTransactions().get(0).getCrossEntry(), notNullValue());
assertThat(second.getTransactions().get(0).getType(), is(AccountTransaction.Type.TRANSFER_OUT));
applyFixes(client, issues);
}
@Test
public void testWhenQuotesAreOnlyAvailableFromTheMiddleOfTheReportInterval() {
DateMidnight startDate = new DateMidnight(2012, 12, 31);
DateMidnight middleDate = new DateMidnight(2013, 2, 18);
DateMidnight endDate = new DateMidnight(2013, 4, 1);
// create model
Client client = new Client();
Account account = new Account();
client.addAccount(account);
addT(
account,
startDate.toCalendar(Locale.getDefault()),
Type.DEPOSIT,
100 * Values.Amount.factor());
addT(
account,
startDate.plusDays(10).toCalendar(Locale.getDefault()),
Type.INTEREST,
10 * Values.Amount.factor());
Security security = new Security();
client.addSecurity(security);
generatePrices(security, 50 * Values.Amount.factor(), middleDate, endDate);
// calculate performance indices
List<Exception> warnings = new ArrayList<Exception>();
ReportingPeriod reportInterval =
new ReportingPeriod.FromXtoY(startDate.toDate(), endDate.toDate());
ClientIndex clientIndex = PerformanceIndex.forClient(client, reportInterval, warnings);
PerformanceIndex securityIndex = PerformanceIndex.forSecurity(clientIndex, security, warnings);
// asserts
assertTrue(warnings.isEmpty());
Date[] clientDates = clientIndex.getDates();
Date[] securityDates = securityIndex.getDates();
assertThat(securityDates[0], is(middleDate.toDate()));
assertThat(securityDates[securityDates.length - 1], is(endDate.toDate()));
assertThat(
new DateMidnight(clientDates[clientDates.length - 1]),
is(new DateMidnight(securityDates[securityDates.length - 1])));
double[] clientAccumulated = clientIndex.getAccumulatedPercentage();
double[] securityAccumulated = securityIndex.getAccumulatedPercentage();
int index = Days.daysBetween(startDate, middleDate).getDays();
assertThat(new DateMidnight(clientDates[index]), is(middleDate));
assertThat(securityAccumulated[0], IsCloseTo.closeTo(clientAccumulated[index], 0.000001d));
long middlePrice = security.getSecurityPrice(middleDate.toDate()).getValue();
long lastPrice = security.getSecurityPrice(endDate.toDate()).getValue();
// 10% is interest of the deposit
double performance = (double) (lastPrice - middlePrice) / (double) middlePrice + 0.1d;
assertThat(
securityAccumulated[securityAccumulated.length - 1],
IsCloseTo.closeTo(performance, 0.000001d));
}
