/** * Bad case: Test access of an inexistent provider within a chain of providers (all other providers must be valid). * Should throw a MonetaryException */ @Test(expectedExceptions = MonetaryException.class, description = "4.3.1 Bad case: Access invalid " + "ExchangeRateProvider, expect MonetaryException thrown, using explicit provider.") @SpecAssertion(id = "431-A7", section = "4.3.1", note = "Accessing an invalid provider name within a name chain, should throw a MonetaryException.") public void testUseInvalidProviderWithinChain() { MonetaryConversions.getExchangeRateProvider("TestRateProvider", "Dhdkjdhskljdsudgsdkjgjk sgdsjdg"); }
/** * Bad case: Test access of an inexistent provider. Should throw a MonetaryException */ @Test(expectedExceptions = MonetaryException.class, description = "4.3.1 Bad case: Access invalid " + "ExchangeRateProvider, expect MonetaryException thrown, using default provider chain.") @SpecAssertion(id = "431-A6", section = "4.3.1", note = "Accessing an invalid provider name, should throw a MonetaryException.") public void testUseInvalidProvider() { MonetaryConversions.getExchangeRateProvider("Dhdkjdhskljdsudgsdkjgjk sgdsjdg"); }
/** * Access an instance of {@link CurrencyConversion} using the * {@link ExchangeRateProviderSupplier}. * * @param provider * the exchange rate provider. * @param providers * the exchange rate provider. * @return the exchange rate provider. * @throws IllegalArgumentException * if no such {@link ExchangeRateProvider} is available. */ public static ExchangeRateProvider getExchangeRateProvider( ExchangeRateProviderSupplier provider, ExchangeRateProviderSupplier... providers) { List<ExchangeRateProviderSupplier> suppliers = new ArrayList<>(); suppliers.add(Objects.requireNonNull(provider)); suppliers.addAll(Arrays.asList(providers)); String[] array = suppliers.stream() .map(ExchangeRateProviderSupplier::get).toArray(String[]::new); return getExchangeRateProvider(array); } /**
/** * Access the default provider chain. Compare with entries from javamoney.properties. The chain must not be empty! */ @Test(description = "4.3.1 Access and test the default conversion provider chain.") @SpecAssertion(id = "431-A4", section = "4.3.1") public void testDefaultProviderChainIsDefined() { ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider(); AssertJUnit.assertNotNull("No default ExchangeRateProvider returned.", prov); // we cannot test more here... }
/** * 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 } } }
/** * 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())); }
public static void main(String[] args) { ExchangeRateProvider imfRateProvider = MonetaryConversions .getExchangeRateProvider("IMF"); ExchangeRateProvider ecbRateProvider = MonetaryConversions .getExchangeRateProvider("ECB"); CurrencyUnit real = Monetary.getCurrency("BRL"); CurrencyUnit dollar = Monetary.getCurrency(Locale.US); CurrencyConversion ecbDollarConvertion = ecbRateProvider .getCurrencyConversion(dollar); CurrencyConversion imfDollarConvertion = imfRateProvider .getCurrencyConversion(dollar); MonetaryAmount money = Money.of(10, real); System.out.println(money.with(ecbDollarConvertion)); System.out.println(money.with(imfDollarConvertion)); }
/** * 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); } }
/** * 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 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 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); } }
/** * 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); } }