How to use

getExchangeRate

method

in

javax.money.convert.ExchangeRateProvider

/**
 * Access a {@link ExchangeRate} using the given currencies. The
 * {@link ExchangeRate} may be, depending on the data provider, eal-time or
 * deferred. This method should return the rate that is <i>currently</i>
 * valid.
 *
 * @param baseCode base currency code, not {@code null}
 * @param termCode term/target currency code, not {@code null}
 * @return the matching {@link ExchangeRate}.
 * @throws CurrencyConversionException If no such rate is available.
 * @throws MonetaryException           if one of the currency codes passed is not valid.
 */
default ExchangeRate getExchangeRate(String baseCode, String termCode){
  return getExchangeRate(Monetary.getCurrency(baseCode), Monetary.getCurrency(termCode));
}

/**
 * Bad case: try accessing rates with inconsistent/invalid data.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Bad case: try accessing exchange rates with invalid base currency code.")
@SpecAssertion(id = "433-A3", section = "4.3.3")
public void testInvalidUsage_InvalidSourceCurrency() {
  for (String providerID : MonetaryConversions.getConversionProviderNames()) {
    if ("TestRateProvider".equals(providerID)) {
      continue;
    }
    ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(providerID);
    try {
      prov.getExchangeRate("dhdjbdjd", "CHF");
      Assert.fail(
          "ExchangeRateProvider should throw UnknownCurrencyException when an invalid source currency " +
              "is passed to getExchangeRate(String,String), provider: " +
              providerID);
    } catch (UnknownCurrencyException e) {
      // OK
    }
  }
}

/**
 * Access a {@link ExchangeRate} using the given currencies. The
 * {@link ExchangeRate} may be, depending on the data provider, eal-time or
 * deferred. This method should return the rate that is <i>currently</i>
 * valid.
 *
 * @param base base {@link CurrencyUnit}, not {@code null}
 * @param term term {@link CurrencyUnit}, not {@code null}
 * @throws CurrencyConversionException If no such rate is available.
 */
default ExchangeRate getExchangeRate(CurrencyUnit base, CurrencyUnit term){
  Objects.requireNonNull(base, "Base Currency is null");
  Objects.requireNonNull(term, "Term Currency is null");
  return getExchangeRate(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build());
}

/**
 * Bad case: try accessing rates with inconsistent/invalid data.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Bad case: try accessing exchange rates with null base currency code.")
@SpecAssertion(id = "433-A3", section = "4.3.3")
public void testInvalidUsage_NullSourceCurrency() {
  for (String providerID : MonetaryConversions.getConversionProviderNames()) {
    if ("TestRateProvider".equals(providerID)) {
      continue;
    }
    ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(providerID);
    try {
      prov.getExchangeRate(null, "CHF");
      Assert.fail("ExchangeRateProvider should throw NullPointerException when an null source currency " +
          "is passed to getExchangeRate(String,String), provider: " +
          providerID);
    } catch (NullPointerException e) {
      // OK
    }
  }
}

/**
 * Bad case: try accessing rates with inconsistent/invalid data.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Bad case: try accessing exchange rates with null term currency code.")
@SpecAssertion(id = "433-A3", section = "4.3.3")
public void testInvalidUsage_NullTargetCurrency() {
  for (String providerID : MonetaryConversions.getConversionProviderNames()) {
    if ("TestRateProvider".equals(providerID)) {
      continue;
    }
    ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(providerID);
    try {
      prov.getExchangeRate("CHF", null);
      Assert.fail("ExchangeRateProvider should throw NullPointerException when an null target currency " +
          "is passed to getExchangeRate(String,String), provider: " +
          providerID);
    } catch (NullPointerException e) {
      // OK
    }
  }
}

/**
 * Bad case: try accessing rates with inconsistent/invalid data.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Bad case: try accessing exchange rates with null ConversionQuery.")
@SpecAssertion(id = "433-A3", section = "4.3.3")
public void testInvalidUsage_InvalidSourceCurrencyAndContext() {
  for (String providerID : MonetaryConversions.getConversionProviderNames()) {
    if ("TestRateProvider".equals(providerID)) {
      continue;
    }
    ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(providerID);
    try {
      prov.getExchangeRate(null);
      Assert.fail("ExchangeRateProvider should throw NPE when an null ConversionQuery " +
          "is passed to getExchangeRate(ConversionQuery), provider: " +
          providerID);
    } catch (NullPointerException e) {
      // OK
    }
  }
}

public static void main(String... args){
  System.out.println("Default conversion chain -> " + MonetaryConversions.getDefaultConversionProviderChain());
  ExchangeRateProvider provider = MonetaryConversions.getExchangeRateProvider("IDENT");
  System.out.println("IDENT provider -> " + provider);
  provider = MonetaryConversions.getExchangeRateProvider("IDENT", "ECB");
  System.out.println("IDENT, ECB provider -> " + provider);
  System.out.println(provider.getExchangeRate("CHF", "EUR"));
  System.out.println(provider.getExchangeRate("CHF", "CHF"));
  provider = MonetaryConversions.getExchangeRateProvider("IDENT", "IMF");
  System.out.println(provider.getExchangeRate("TND", "BRL"));
  provider = MonetaryConversions.getExchangeRateProvider("IDENT", "ECB", "ECB-HIST");
  System.out.println("CHF -> EUR (today) -> " + provider.getExchangeRate(ConversionQueryBuilder.of()
      .setBaseCurrency("EUR").setTermCurrency("CHF")
      //.set(new Date() LocalDate.of(2008, 1, 8))
      .build()));
  System.out.println("CHF -> EUR (1.8.2008) -> " + provider.getExchangeRate(ConversionQueryBuilder.of()
      .setBaseCurrency("EUR").setTermCurrency("CHF")
      //.set(LocalDate.of(2008, 1, 8))
      .build()));
}

@Override
public ExchangeRate getExchangeRate(ConversionQuery conversionQuery) {
  for (ExchangeRateProvider prov : this.providers) {
    try {
      if (prov.isAvailable(conversionQuery)) {
        ExchangeRate rate = prov.getExchangeRate(conversionQuery);
        if (Objects.nonNull(rate)) {
          return rate;
        }
      }
    } catch (Exception e) {
      Logger.getLogger(getClass().getName()).log(Level.WARNING,
          "Rate Provider did not return data though at check before data was flagged as available," +
              " provider=" + prov.getContext().getProviderName() + ", query=" + conversionQuery);
    }
  }
  throw new CurrencyConversionException(conversionQuery.getBaseCurrency(), conversionQuery.getCurrency(), null,
      "All delegate prov iders failed to deliver rate, providers=" + this.providers +
          ", query=" + conversionQuery);
}

/**
 * Bad case: try accessing rates with inconsistent/invalid data.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Bad case: try accessing exchange rates with null base CurrencyUnit.")
@SpecAssertion(id = "433-A3", section = "4.3.3")
public void testInvalidUsage_NullSourceCurrencyUnit() {
  for (String providerID : MonetaryConversions.getConversionProviderNames()) {
    ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(providerID);
    try {
      prov.getExchangeRate(null, Monetary.getCurrency("CHF"));
      Assert.fail("ExchangeRateProvider should throw NullPointerException when an null source currency " +
          "is passed to getExchangeRate(CurrencyUnit,CurrencyUnit), provider: " +
          providerID);
    } catch (NullPointerException e) {
      // OK
    }
  }
}

/**
 * Bad case: try accessing rates with inconsistent/invalid data.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Bad case: try accessing exchange rates with null term CurrencyUnit.")
@SpecAssertion(id = "433-A3", section = "4.3.3")
public void testInvalidUsage_NullTargetCurrencyUnit() {
  for (String providerID : MonetaryConversions.getConversionProviderNames()) {
    ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(providerID);
    try {
      prov.getExchangeRate(Monetary.getCurrency("CHF"), null);
      Assert.fail("ExchangeRateProvider should throw NullPointerException when an invalid target currency " +
          "is passed to getExchangeRate(CurrencyUnit,CurrencyUnit), provider: " +
          providerID);
    } catch (NullPointerException e) {
      // OK
    }
  }
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access to identity conversion rate for CurrencyUnits, using default provider")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessRates_IdentityRatesWithUnits() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(); // Use default provider
  for (CurrencyUnit unit : Monetary.getCurrencies()) {
    ExchangeRate rate = prov.getExchangeRate(unit, unit);
    AssertJUnit.assertNotNull(
        "Identity rate, accessed by getExchangeRate(CurrencyUnit, CurrencyUnit), is not defined for " +
            unit.getCurrencyCode(), rate);
  }
}

/**
 * Get the exchange rate type that this provider instance is providing data
 * for.
 *
 * @return the exchange rate type if this instance.
 */
@Override
public ExchangeRate getExchangeRate(MonetaryAmount amount) {
  return this.rateProvider.getExchangeRate(ConversionQueryBuilder
      .of(conversionQuery).setBaseCurrency(amount.getCurrency())
      .build());
  // return this.rateProvider.getExchangeRate(amount.getCurrency(),
  // getCurrency());
}

/**
 * Test correct rate evaluation for different provider chains, providers defined by the TCK.<p>
 * Hint do not use non TCK provider for this test, it will make results undeterministic.
 */
@Test(description = "4.3.4 Test correct rate evaluation for different conversion provider chains, " +
    "with duplicate provider entries.")
@SpecAssertion(id = "434-A1", section = "4.3.4")
public void testCorrectRateEvaluationInChain_sameProviders() {
  ExchangeRateProvider prov1 = MonetaryConversions
      .getExchangeRateProvider("TestRateProvider1", "TestRateProvider1", "TestRateProvider1");
  ExchangeRate rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1", "TestRateProvider1");
  rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
  prov1 = MonetaryConversions.getExchangeRateProvider("TestRateProvider1");
  rate = prov1.getExchangeRate("CHF", "EUR");
  AssertJUnit.assertEquals("Invalid ExchangeRateProvider selected.", rate.getFactor().intValueExact(), 1);
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access to conversion rate for currency codes, using default provider.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessRates_IdentityRatesWithCodes() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(); // Use default provider
  for (CurrencyUnit unit : Monetary.getCurrencies()) {
    ExchangeRate rate = prov.getExchangeRate(unit.getCurrencyCode(), unit.getCurrencyCode());
    AssertJUnit.assertNotNull(
        "Identity rate, accessed by getExchangeRate(String, String), is not defined for " +
            unit.getCurrencyCode(), rate);
  }
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access to conversion rate for CurrencyQuery, using default provider.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessRates_IdentityRatesWithUnitsAndContext() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(); // Use default provider
  for (CurrencyUnit unit : Monetary.getCurrencies()) {
    ExchangeRate rate = prov.getExchangeRate(
        ConversionQueryBuilder.of().setBaseCurrency(unit).setTermCurrency(unit).build());
    AssertJUnit.assertNotNull("Identity rate, accessed by getExchangeRate(ConversionQuery), " +
        "is not defined for " +
        unit.getCurrencyCode(), rate);
  }
}

/**
 * The method reverses the {@link ExchangeRate} to a rate mapping from term
 * to base {@link CurrencyUnit}. Hereby the factor must <b>not</b> be
 * recalculated as {@code 1/oldFactor}, since typically reverse rates are
 * not symmetric in most cases.
 *
 * @return the matching reversed {@link ExchangeRate}, or {@code null}, if
 * the rate cannot be reversed.
 */
default ExchangeRate getReversed(ExchangeRate rate){
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3 Test access of Conversion Rates, using TCK provided rate provider.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRates() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    if (base.equals(FOO_UNIT)) {
      continue;
    }
    ExchangeRate rate = prov.getExchangeRate(base, FOO_UNIT);
    AssertJUnit.assertNotNull(
        "Identity rate, accessed by getExchangeRate(CurrencyUnit, CurrencyUnit), is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}

/**
 * Compare conversions done with exchange rates provided for same currency pair.
 */
@Test(description = "4.3.2 Test correct ExchangeRate is returned for CHF -> FOO, using TestRateProvider.")
@SpecAssertion(id = "432-A2", section = "4.3.2")
public void testConversionComparedWithRate() {
  final CurrencyUnit FOO = new TestCurrencyUnit("FOO");
  ExchangeRate rate = MonetaryConversions.getExchangeRateProvider("TestRateProvider")
      .getExchangeRate(Monetary.getCurrency("CHF"), FOO);
  AssertJUnit.assertEquals(rate.getBaseCurrency(), Monetary.getCurrency("CHF"));
  AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO.getCurrencyCode());
  AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  AssertJUnit.assertEquals("TestRateProvider", rate.getContext().getProviderName());
}

/**
 * Ensure additional ConversionContext is passed correctly to SPIs.<p>
 * Hint: this assertion will require some custom SPIs to be registered and selected for chain inclusion!
 */
@Test(description = "4.3.3 Ensure additional ConversionQuery data is passed correctly to SPIs.")
@SpecAssertion(id = "433-A2", section = "4.3.3")
public void testPassingOverConversionContextToSPIs() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  ConversionQuery ctx = ConversionQueryBuilder.of().set(Locale.CANADA).set("Foo", "bar").setBaseCurrency(FOO_UNIT)
      .setTermCurrency(Monetary.getCurrency("XXX")).build();
  ExchangeRate rate = prov.getExchangeRate(ctx);
  AssertJUnit.assertNotNull("No test rate returned by getExchangeRate(ConversionQuery), " +
      "probably TestProvider is not correct registered.");
  AssertJUnit.assertEquals(
      "Text parameter Locale.class was not correctly passed to ExchangeRateProvider implementation.", "bar",
      rate.getContext().getText("Foo"));
  AssertJUnit.assertEquals(
      "Object parameter Locale.class was not correctly passed to ExchangeRateProvider implementation.",
      Locale.CANADA, rate.getContext().get(Locale.class));
}

/**
 * Test access to conversion rates.<p>
 * Hint: this assertion will require multiple tests to be written!
 */
@Test(description = "4.3.3  Test access to conversion rates, including known factor, using TestRateProvider.")
@SpecAssertion(id = "433-A1", section = "4.3.3")
public void testAccessKnownRatesWithCodesAndContext() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  // Use test provider
  for (CurrencyUnit base : Monetary.getCurrencies()) {
    ExchangeRate rate = prov.getExchangeRate(base, FOO_UNIT);
    AssertJUnit
        .assertNotNull("Identity rate, accessed by getExchangeRate(String, String, ConversionContext), " +
            "is not defined for " +
            base.getCurrencyCode() + " -> " + FOO_UNIT.getCurrencyCode(), rate);
    AssertJUnit.assertEquals(rate.getBaseCurrency().getCurrencyCode(), base.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO_UNIT.getCurrencyCode());
    AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  }
}