/** * 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"); }
@SpecAssertion(id = "431-A2", section = "4.3.1") public void testConversionsAreAvailable() { for (String providerName : MonetaryConversions.getConversionProviderNames()) { try { if (MonetaryConversions.isConversionAvailable("XXX", providerName)) { CurrencyConversion conv = MonetaryConversions.getConversion("XXX", providerName); AssertJUnit.assertNotNull( "CurrencyConversion returned from MonetaryConversions.getConversion(String, " + " String...): " + providerName, MonetaryConversions.isConversionAvailable("XXX", providerName)); "CurrencyConversion is not flagged as NOT available, though it is not accessible from " + "MonetaryConversions.getConversion(String, String...): " + providerName, MonetaryConversions.isConversionAvailable("XXX", providerName));
/** * Get the default provider used. * * @return the default provider, never {@code null}. */ public static List<String> getDefaultConversionProviderChain(){ List<String> defaultChain = getMonetaryConversionsSpi() .getDefaultProviderChain(); Objects.requireNonNull(defaultChain, "No default provider chain provided by SPI: " + getMonetaryConversionsSpi().getClass().getName()); return defaultChain; }
/** * 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 converting from/to a null currency, ensure NullPointerException is thrown. */ @Test(expectedExceptions = NullPointerException.class, description = "4.3.2 Bad case: Access CurrencyConversion with a currency code==null, ensure " + "NullPointerException is thrown.") @SpecAssertion(id = "432-A4", section = "4.3.2") public void testNullConversion2() { MonetaryConversions.getConversion((String) null); }
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())); }
/** * Access an instance of {@link CurrencyConversion} using the given * providers as a provider chain. Use {@link #getConversionProviderNames()}s * to check, which are available. * * @return the exchange rate provider. * @throws IllegalArgumentException if no such {@link ExchangeRateProvider} is available. */ public static ExchangeRateProvider getExchangeRateProvider(String... providers){ if(providers.length == 0){ List<String> defaultProviderChain = getDefaultConversionProviderChain(); return getMonetaryConversionsSpi().getExchangeRateProvider(ConversionQueryBuilder.of().setProviderNames( defaultProviderChain.toArray(new String[defaultProviderChain.size()])).build()); } ExchangeRateProvider provider = getMonetaryConversionsSpi() .getExchangeRateProvider(ConversionQueryBuilder.of().setProviderNames(providers).build()); return Optional.ofNullable(provider) .orElseThrow(() -> new MonetaryException("No such rate provider: " + Arrays.toString(providers))); }
/** * Ensure at least one conversion provider is available.<p> * Hint: ignore all TCK test providers, only count up productive providers. */ @Test(description = "4.3.1 Ensure at least one conversion provider is available, TestRateProvider must be present.") @SpecAssertion(id = "431-A1", section = "4.3.1") public void testProvidersAvailable() { int providerCount = 0; for (String providername : MonetaryConversions.getConversionProviderNames()) { if (!"TestRateProvider".equals(providername)) { providerCount++; } } AssertJUnit.assertTrue("At least one conversion provider must be available/registered.", providerCount > 0); }
/** * 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 converting from/to a null currency, ensure NullPointerException is thrown. */ @Test(expectedExceptions = NullPointerException.class, description = "4.3.2 Bad case: Access CurrencyConversion " + "with a CurrencyUnit==null, ensure NullPointerException is thrown.") @SpecAssertion(id = "432-A4", section = "4.3.2") public void testNullConversion1() { MonetaryConversions.getConversion((CurrencyUnit) null); }
/** * Access an instance of {@link CurrencyConversion} for the given providers. * Use {@link #getConversionProviderNames()} to check, which are available. * * @param termCurrency the terminating or target currency, not {@code null} * @param providers Additional providers, for building a provider chain * @return the exchange rate type if this instance. * @throws IllegalArgumentException if no such {@link ExchangeRateProvider} is available. */ public static CurrencyConversion getConversion(CurrencyUnit termCurrency, String... providers){ Objects.requireNonNull(providers); Objects.requireNonNull(termCurrency); if(providers.length == 0){ return getMonetaryConversionsSpi().getConversion( ConversionQueryBuilder.of().setTermCurrency(termCurrency).setProviderNames(getDefaultConversionProviderChain()) .build()); } return getMonetaryConversionsSpi().getConversion( ConversionQueryBuilder.of().setTermCurrency(termCurrency).setProviderNames(providers).build()); }
/** * Test availability of 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 availability of TCK provided providers.") @SpecAssertion(id = "434-A3", section = "4.3.4") public void testTCKRateChainAvailability() { Collection<String> provNames = MonetaryConversions.getConversionProviderNames(); AssertJUnit.assertTrue("TCK ExchangeRateProvider is not registered: TestRateProvider", provNames.contains("TestRateProvider")); AssertJUnit.assertTrue("TCK ExchangeRateProvider is not registered:TestRateProvider1", provNames.contains("TestRateProvider1")); AssertJUnit.assertTrue("TCK ExchangeRateProvider is not registered: TestRateProvider2", provNames.contains("TestRateProvider2")); AssertJUnit.assertTrue("TCK ExchangeRateProvider is not registered: TestRateProvider3", provNames.contains("TestRateProvider3")); AssertJUnit.assertTrue("TCK ExchangeRateProvider is not registered: TestRateProvider02", provNames.contains("TestRateProvider02")); }
/** * 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"); }
/** * 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 } } }
@SpecAssertion(id = "431-A2", section = "4.3.1") public void testConversionsAreAvailableWithQuery() { for (String providerName : MonetaryConversions.getConversionProviderNames()) { ConversionQuery query = ConversionQueryBuilder.of().setTermCurrency("XXX").setProviderNames(providerName).build(); try { if (MonetaryConversions.isConversionAvailable(query)) { CurrencyConversion conv = MonetaryConversions.getConversion(query); AssertJUnit.assertNotNull( "CurrencyConversion returned from MonetaryConversions.getConversion(ConversionQuery) must" + .assertTrue("CurrencyConversion is not flagged as available though it was returned from " + "MonetaryConversions.getConversion(ConversionQuery): " + providerName, MonetaryConversions.isConversionAvailable(query)); "CurrencyConversion is not flagged as not available, though it was not returned from " + "MonetaryConversions.getConversion(ConversionQuery): " + providerName, MonetaryConversions.isConversionAvailable(query));
/** * Access an instance of {@link CurrencyConversion} for the given providers. * Use {@link #getConversionProviderNames()}} to check, which are available. * * @param termCurrencyCode the terminating or target currency code, not {@code null} * @param providers Additional providers, for building a provider chain * @return the exchange rate type if this instance. * @throws MonetaryException if no such {@link ExchangeRateProvider} is available or if no {@link CurrencyUnit} was * matching the given currency code. */ public static CurrencyConversion getConversion(String termCurrencyCode, String... providers){ Objects.requireNonNull(termCurrencyCode, "Term currency code may not be null"); return getConversion(Monetary.getCurrency(termCurrencyCode), providers); }
/** * Checks if a {@link javax.money.convert.CurrencyConversion} is available for the given parameters. * * @param conversionQuery the {@link javax.money.convert.ConversionQuery}, not null. * @return true, if a conversion is accessible from {@link #getConversion(ConversionQuery)}. */ public static boolean isConversionAvailable(ConversionQuery conversionQuery){ return getMonetaryConversionsSpi().isConversionAvailable(conversionQuery); }
/** * 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); } /**
/** * 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 } } }
/** * Test if all providers returns valid meta data. * * @see javax.money.convert.ProviderContext */ @Test(description = "4.3.1 Test if all CurrencyConversion instances returns valid ConversionContext, accessed by " + "currency code.") @SpecAssertion(id = "431-A3", section = "4.3.1") public void testProviderMetadata2() { for (String providerName : MonetaryConversions.getConversionProviderNames()) { if (MonetaryConversions.isConversionAvailable("XXX", providerName)) { CurrencyConversion conv = MonetaryConversions.getConversion("XXX", providerName); ConversionContext ctx = conv.getContext(); AssertJUnit.assertNotNull( "ExchangeProvider must return a valid ProviderContext, but returned null: " + providerName, ctx); AssertJUnit.assertEquals("ExchangeProvider's ProviderContext returns invalid name: " + providerName, providerName, ctx.getProviderName()); AssertJUnit.assertNotNull( "ExchangeProvider's ProviderContext declares invalid RateTypes to be returned (null): " + providerName, ctx.getRateType()); } } }