/** * 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); } }