Esempio n. 1
0
  @Test
  public void testExcelSampleAggregatedWeekly() {
    // first day of week is locale dependent
    Locale locale = Locale.getDefault();
    Locale.setDefault(Locale.GERMAN);

    try {
      Client client = createClient();

      ReportingPeriod.FromXtoY reportInterval =
          new ReportingPeriod.FromXtoY( //
              LocalDate.of(2011, Month.DECEMBER, 31), LocalDate.of(2012, Month.JANUARY, 8));
      CurrencyConverter converter = new TestCurrencyConverter();
      PerformanceIndex index =
          PerformanceIndex.forClient(client, converter, reportInterval, new ArrayList<Exception>());

      index = Aggregation.aggregate(index, Aggregation.Period.WEEKLY);

      assertNotNull(index);

      double[] delta = index.getDeltaPercentage();
      assertThat(delta.length, is(2));
      assertThat(delta[0], IsCloseTo.closeTo(0.023d, PRECISION));
      assertThat(delta[1], IsCloseTo.closeTo(-0.0713587d, PRECISION));

      double[] accumulated = index.getAccumulatedPercentage();
      assertThat(accumulated[0], IsCloseTo.closeTo(0.023d, PRECISION));
      assertThat(accumulated[1], IsCloseTo.closeTo(-0.05d, PRECISION));
    } finally {
      Locale.setDefault(locale);
    }
  }
Esempio n. 2
0
  @Test
  public void testThatTransferalsDoNotChangePerformance() {
    double[] delta = {0d, 0.023d, 0.043d, 0.02d, 0.05d, 0.08d, 0.1d, 0.04d, -0.05d};
    long[] transferals = {1000000, 0, 20000, -40000, 0, 0, 540000, -369704, 0};
    long[] transferals2 = {1000000, 0, 0, 0, 0, 0, 0, 0, 0};

    Client client = createClient(delta, transferals);

    ReportingPeriod.FromXtoY period =
        new ReportingPeriod.FromXtoY(
            LocalDate.of(2012, Month.JANUARY, 1), //
            LocalDate.of(2012, Month.JANUARY, 9));
    CurrencyConverter converter = new TestCurrencyConverter();
    ClientIndex index =
        PerformanceIndex.forClient(client, converter, period, new ArrayList<Exception>());

    double[] accumulated = index.getAccumulatedPercentage();
    for (int ii = 0; ii < accumulated.length; ii++)
      assertThat(accumulated[ii], IsCloseTo.closeTo(delta[ii], PRECISION));

    Client anotherClient = createClient(delta, transferals2);
    index =
        PerformanceIndex.forClient(anotherClient, converter, period, new ArrayList<Exception>());

    accumulated = index.getAccumulatedPercentage();
    for (int ii = 0; ii < accumulated.length; ii++)
      assertThat(accumulated[ii], IsCloseTo.closeTo(delta[ii], PRECISION));
  }
Esempio n. 3
0
  @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();

    new AccountBuilder() //
        .deposit_(startDate, 100 * Values.Amount.factor()) //
        .interest(startDate.plusDays(10), 10 * Values.Amount.factor()) //
        .addTo(client);

    Security security =
        new SecurityBuilder() //
            .generatePrices(50 * Values.Amount.factor(), middleDate, endDate) //
            .addTo(client);

    // 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));
  }
Esempio n. 4
0
  @Test
  public void testThatInterstWithoutInvestmentDoesNotCorruptResultAndIsReported() {
    Client client = new Client();
    new AccountBuilder() //
        .interest("2012-01-02", 100) //
        .addTo(client);

    ReportingPeriod.FromXtoY period =
        new ReportingPeriod.FromXtoY(
            LocalDate.of(2012, Month.JANUARY, 1), //
            LocalDate.of(2012, Month.JANUARY, 9));

    List<Exception> errors = new ArrayList<Exception>();
    CurrencyConverter converter = new TestCurrencyConverter();
    ClientIndex index = PerformanceIndex.forClient(client, converter, period, errors);

    double[] accumulated = index.getAccumulatedPercentage();
    for (int ii = 0; ii < accumulated.length; ii++)
      assertThat(accumulated[ii], IsCloseTo.closeTo(0d, PRECISION));

    assertThat(errors.size(), is(1));
    assertThat(
        errors.get(0).getMessage(),
        startsWith(
            Messages.MsgDeltaWithoutAssets.substring(
                0, Messages.MsgDeltaWithoutAssets.indexOf('{'))));
  }
Esempio n. 5
0
  @Test
  public void testThatDepositsOnTheLastDayArePerformanceNeutral() {
    Client client = new Client();

    new AccountBuilder() //
        .deposit_("2012-01-01", 10000) //
        .interest("2012-01-02", 1000) //
        .deposit_("2012-01-10", 10000) //
        .addTo(client);

    ReportingPeriod.FromXtoY reportInterval =
        new ReportingPeriod.FromXtoY(
            LocalDate.of(2012, Month.JANUARY, 1), //
            LocalDate.of(2012, Month.JANUARY, 10));
    CurrencyConverter converter = new TestCurrencyConverter();
    PerformanceIndex index =
        PerformanceIndex.forClient(client, converter, reportInterval, new ArrayList<Exception>());

    double[] accumulated = index.getAccumulatedPercentage();
    assertThat(accumulated[accumulated.length - 2], IsCloseTo.closeTo(0.1d, PRECISION));
    assertThat(accumulated[accumulated.length - 1], IsCloseTo.closeTo(0.1d, PRECISION));
  }
Esempio n. 6
0
  @Test
  public void testThatNoValuationResultsInZeroPerformance() {
    Client client = new Client();

    ReportingPeriod.FromXtoY period =
        new ReportingPeriod.FromXtoY(
            LocalDate.of(2012, Month.JANUARY, 1), //
            LocalDate.of(2012, Month.JANUARY, 9));
    CurrencyConverter converter = new TestCurrencyConverter();
    ClientIndex index =
        PerformanceIndex.forClient(client, converter, period, new ArrayList<Exception>());

    double[] accumulated = index.getAccumulatedPercentage();
    for (int ii = 0; ii < accumulated.length; ii++)
      assertThat(accumulated[ii], IsCloseTo.closeTo(0d, PRECISION));
  }
  @Test
  public void testErtragsgutschrift2() throws IOException {
    DeutscheBankPDFExctractor extractor =
        new DeutscheBankPDFExctractor(new Client()) {
          @Override
          String strip(File file) throws IOException {
            return from(file.getName());
          }
        };
    List<Exception> errors = new ArrayList<Exception>();

    List<Item> results =
        extractor.extract(Arrays.asList(new File("DeutscheBankErtragsgutschrift2.txt")), errors);

    assertThat(errors, empty());
    assertThat(results.size(), is(2));
    new AssertImportActions().check(results, CurrencyUnit.EUR);

    // check security
    Security security =
        results.stream().filter(i -> i instanceof SecurityItem).findFirst().get().getSecurity();
    assertThat(security.getName(), is("ISHS-MSCI N. AMERIC.UCITS ETF BE.SH.(DT.ZT.)"));
    assertThat(security.getIsin(), is("DE000A0J2060"));
    assertThat(security.getWkn(), is("A0J206"));
    assertThat(security.getCurrencyCode(), is("USD"));

    // check transaction
    Optional<Item> item = results.stream().filter(i -> i instanceof TransactionItem).findFirst();
    assertThat(item.isPresent(), is(true));
    assertThat(item.get().getSubject(), instanceOf(AccountTransaction.class));

    AccountTransaction transaction = (AccountTransaction) item.get().getSubject();
    assertThat(transaction.getType(), is(AccountTransaction.Type.DIVIDENDS));
    assertThat(transaction.getSecurity(), is(security));
    assertThat(transaction.getDate(), is(LocalDate.parse("2015-03-24")));
    assertThat(transaction.getMonetaryAmount(), is(Money.of(CurrencyUnit.EUR, 16_17L)));
    assertThat(transaction.getShares(), is(Values.Share.factorize(123)));

    Optional<Unit> grossValue = transaction.getUnit(Unit.Type.GROSS_VALUE);
    assertThat(grossValue.isPresent(), is(true));
    assertThat(grossValue.get().getAmount(), is(Money.of("EUR", 16_17L)));
    assertThat(grossValue.get().getForex(), is(Money.of("USD", 17_38L)));
    assertThat(
        grossValue.get().getExchangeRate().doubleValue(), IsCloseTo.closeTo(0.930578, 0.000001));
  }
Esempio n. 8
0
  @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();

    new AccountBuilder() //
        .deposit_(startDate, startPrice) //
        .addTo(client);

    Security security =
        new SecurityBuilder() //
            .generatePrices(startPrice, startDate, endDate) //
            .addTo(client);

    // 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));
  }
Esempio n. 9
0
  @Test
  public void testThatPerformanceOfAnInvestmentIntoAnIndexIsIdenticalToIndex() {
    LocalDate startDate = LocalDate.of(2012, 1, 1);
    LocalDate endDate = LocalDate.of(2012, 4, 29); // a weekend
    long startPrice = Values.Quote.factorize(100);

    Client client = new Client();

    Security security =
        new SecurityBuilder() //
            .generatePrices(startPrice, startDate, endDate) //
            .addTo(client);

    PortfolioBuilder portfolio = new PortfolioBuilder(new Account());

    // add some buy transactions
    LocalDate date = startDate;
    while (date.isBefore(endDate)) {
      long p = security.getSecurityPrice(date).getValue();
      portfolio.inbound_delivery(security, date, Values.Share.factorize(100), p);
      date = date.plusDays(20);
    }

    portfolio.addTo(client);

    ReportingPeriod.FromXtoY period = new ReportingPeriod.FromXtoY(startDate, endDate);

    List<Exception> warnings = new ArrayList<Exception>();
    CurrencyConverter converter = new TestCurrencyConverter();
    ClientIndex index = PerformanceIndex.forClient(client, converter, period, warnings);
    assertTrue(warnings.isEmpty());

    double[] accumulated = index.getAccumulatedPercentage();
    long lastPrice = security.getSecurityPrice(endDate).getValue();

    assertThat(
        (double) (lastPrice - startPrice) / (double) startPrice,
        IsCloseTo.closeTo(accumulated[accumulated.length - 1], PRECISION));

    PerformanceIndex benchmark = PerformanceIndex.forSecurity(index, security);
    assertThat(
        benchmark.getFinalAccumulatedPercentage(), is(index.getFinalAccumulatedPercentage()));
  }
Esempio n. 10
0
  @Test
  public void testWhenQuotesAreOnlyAvailableUntilTheMiddleOfTheReportInterval() {
    DateMidnight startDate = new DateMidnight(2012, 12, 31);
    DateMidnight middleDate = new DateMidnight(2013, 2, 18);
    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());
    addT(
        account,
        startDate.plusDays(10).toCalendar(Locale.getDefault()),
        Type.INTEREST,
        10 * Values.Amount.factor());

    Security security = new Security();
    client.addSecurity(security);

    int startPrice = 50 * Values.Amount.factor();
    generatePrices(security, startPrice, startDate, middleDate);

    // 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(startDate.toDate()));
    assertThat(securityDates[securityDates.length - 1], is(middleDate.toDate()));
    assertThat(new DateMidnight(clientDates[0]), is(new DateMidnight(securityDates[0])));

    double[] securityAccumulated = securityIndex.getAccumulatedPercentage();

    int index = Days.daysBetween(startDate, middleDate).getDays();
    assertThat(new DateMidnight(clientDates[index]), is(middleDate));
    assertThat(securityAccumulated[0], IsCloseTo.closeTo(0d, 0.000001d));

    long middlePrice = security.getSecurityPrice(middleDate.toDate()).getValue();
    double performance = (double) (middlePrice - startPrice) / (double) startPrice;
    assertThat(
        securityAccumulated[securityAccumulated.length - 1],
        IsCloseTo.closeTo(performance, 0.000001d));
  }
Esempio n. 11
0
  @Test
  public void testExcelSample() {
    Client client = createClient();

    ReportingPeriod.FromXtoY period =
        new ReportingPeriod.FromXtoY(
            LocalDate.of(2011, Month.DECEMBER, 31), //
            LocalDate.of(2012, Month.JANUARY, 8));
    CurrencyConverter converter = new TestCurrencyConverter();
    ClientIndex index =
        PerformanceIndex.forClient(client, converter, period, new ArrayList<Exception>());

    assertNotNull(index);

    assertThat(period.toInterval(), is(index.getReportInterval().toInterval()));
    assertThat(client, is(index.getClient()));

    LocalDate[] dates = index.getDates();
    assertThat(dates.length, is(Dates.daysBetween(period.getStartDate(), period.getEndDate()) + 1));

    double[] delta = index.getDeltaPercentage();
    assertThat(delta[0], is(0d));
    assertThat(delta[1], IsCloseTo.closeTo(0.023d, PRECISION));
    assertThat(delta[2], IsCloseTo.closeTo(0.0195503d, PRECISION));
    assertThat(delta[3], IsCloseTo.closeTo(-0.0220517d, PRECISION));
    assertThat(delta[4], IsCloseTo.closeTo(0.0294117647d, PRECISION));
    assertThat(delta[5], IsCloseTo.closeTo(0.0285714286d, PRECISION));
    assertThat(delta[6], IsCloseTo.closeTo(0.0185185185d, PRECISION));
    assertThat(delta[7], IsCloseTo.closeTo(-0.0545454545d, PRECISION));
    assertThat(delta[8], IsCloseTo.closeTo(-0.0865384615d, PRECISION));

    double[] accumulated = index.getAccumulatedPercentage();
    assertThat(accumulated[0], is(0d));
    assertThat(accumulated[1], IsCloseTo.closeTo(0.023d, PRECISION));
    assertThat(accumulated[2], IsCloseTo.closeTo(0.043d, PRECISION));
    assertThat(accumulated[3], IsCloseTo.closeTo(0.02d, PRECISION));
    assertThat(accumulated[4], IsCloseTo.closeTo(0.05d, PRECISION));
    assertThat(accumulated[5], IsCloseTo.closeTo(0.08d, PRECISION));
    assertThat(accumulated[6], IsCloseTo.closeTo(0.10d, PRECISION));
    assertThat(accumulated[7], IsCloseTo.closeTo(0.04d, PRECISION));
    assertThat(accumulated[8], IsCloseTo.closeTo(-0.05d, PRECISION));
  }