Removed static references to SPI instances (Tests)

Added tests to ensure that Monetary, MonetaryFormats and
MonetaryConversions are not caching SPI instances when replacing
ServiceProvider using Bootstrap.init()

Author: reallyinsane

pom.xml

@@ -15,7 +15,7 @@
 	<artifactId>money-api</artifactId>
 	<packaging>bundle</packaging>
 
-	<version>1.0.1</version>
+	<version>1.0.2</version>
 	<name>JSR 354 (Money and Currency API)</name>
 	<url>http://java.net/projects/javamoney</url>
 	<inceptionYear>2012</inceptionYear>
@@ -34,6 +34,7 @@
 		<basedir>.</basedir>
 		<!-- Dependency versions -->
 		<testng.version>6.8.5</testng.version>
+        <mockito.version>1.10.19</mockito.version>
 	</properties>
 
 	<organization>
@@ -399,6 +400,12 @@
 				<version>${testng.version}</version>
 				<scope>test</scope>
 			</dependency>
+            <dependency>
+              <groupId>org.mockito</groupId>
+              <artifactId>mockito-all</artifactId>
+              <version>${mockito.version}</version>
+              <scope>test</scope>
+            </dependency>
 		</dependencies>
 	</dependencyManagement>
 
@@ -408,6 +415,11 @@
 			<artifactId>testng</artifactId>
 			<scope>test</scope>
 		</dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <scope>test</scope>
+        </dependency>
 	</dependencies>
 
 	<build>

src/test/java/javax/money/AbstractDynamicServiceProviderTest.java

@@ -0,0 +1,110 @@
+/*
+ * CREDIT SUISSE IS WILLING TO LICENSE THIS SPECIFICATION TO YOU ONLY UPON THE CONDITION THAT YOU
+ * ACCEPT ALL OF THE TERMS CONTAINED IN THIS AGREEMENT. PLEASE READ THE TERMS AND CONDITIONS OF THIS
+ * AGREEMENT CAREFULLY. BY DOWNLOADING THIS SPECIFICATION, YOU ACCEPT THE TERMS AND CONDITIONS OF
+ * THE AGREEMENT. IF YOU ARE NOT WILLING TO BE BOUND BY IT, SELECT THE "DECLINE" BUTTON AT THE
+ * BOTTOM OF THIS PAGE. Specification: JSR-354 Money and Currency API ("Specification") Copyright
+ * (c) 2012-2013, Credit Suisse All rights reserved.
+ */
+package javax.money;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.money.spi.Bootstrap;
+import javax.money.spi.CurrencyProviderSpi;
+import javax.money.spi.ServiceProvider;
+
+import org.mockito.Mockito;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+
+/**
+ * Abstract test supporting to switch SPI implementations by using a ServiceProvider providing manually registered SPIs only. 
+ * @author Matthias Hanisch
+ */
+public abstract class AbstractDynamicServiceProviderTest {
+
+    private ServiceProvider originalServiceProvider;
+    private TestServiceProvider testServiceProvider;
+    
+    /**
+     * Initialized Bootstrap so that default ServiceProvider is enabled. Then stores the default ServiceProvider in
+     * {@link #originalServiceProvider}. Initializes Bootstrap with default ServiceProvider again so that it is
+     * usable in the Test. Also initialized {@link #testServiceProvider}.
+     */
+    @BeforeMethod
+    public void prepare() {
+        Bootstrap.getService(CurrencyProviderSpi.class);
+        ServiceProvider empty = Mockito.mock(ServiceProvider.class);
+        originalServiceProvider= Bootstrap.init(empty);
+        Bootstrap.init(originalServiceProvider);
+        testServiceProvider = new TestServiceProvider();
+    }
+    
+    /**
+     * Restores the default ServiceProvider.
+     */
+    @AfterMethod
+    public void restore() {
+        testServiceProvider.clearServices();
+        Bootstrap.init(originalServiceProvider);
+    }
+    
+    protected final void initTestServiceProvider() {
+        Bootstrap.init(testServiceProvider);
+    }
+    
+    protected final void initOriginalServiceProvider() {
+        Bootstrap.init(originalServiceProvider);
+    }
+
+    /**
+     * Registers a SPI service so that it is accessible via {@link Bootstrap#getService(Class)} when using {@link #testServiceProvider}.
+     * @param serviceType The SPI type.
+     * @param service The SPI instance.
+     */
+    protected final <T> void registerService(Class<T> serviceType, T service) {
+        testServiceProvider.registerService(serviceType, service);
+    }
+    
+    class TestServiceProvider implements ServiceProvider {
+        
+        private Map<Class<?>, List<?>> services = new HashMap<>();
+
+        @Override
+        public int getPriority() {
+            return 0;
+        }
+
+        @Override
+        public <T> List<T> getServices(Class<T> serviceType) {
+            return (List<T>) services.get(serviceType);
+        }
+
+        @Override
+        public <T> T getService(Class<T> serviceType) {
+            List<T> servicesOfType = getServices(serviceType);
+            if(servicesOfType==null||servicesOfType.isEmpty()) {
+                return null;
+            } else {
+                return servicesOfType.get(0);
+            }
+        }
+        
+        public <T> void registerService(Class<T> serviceType, T service) {
+            List<T> servicesOfType = (List<T>) services.get(serviceType);
+            if(servicesOfType==null) {
+                servicesOfType = new ArrayList<>();
+                services.put(serviceType, servicesOfType);
+            }
+            servicesOfType.add(service);
+        }
+        
+        public void clearServices() {
+            services.clear();
+        }
+    }
+}

src/test/java/javax/money/MonetaryDynamicServiceProviderTest.java

@@ -0,0 +1,199 @@
+/*
+ * CREDIT SUISSE IS WILLING TO LICENSE THIS SPECIFICATION TO YOU ONLY UPON THE CONDITION THAT YOU
+ * ACCEPT ALL OF THE TERMS CONTAINED IN THIS AGREEMENT. PLEASE READ THE TERMS AND CONDITIONS OF THIS
+ * AGREEMENT CAREFULLY. BY DOWNLOADING THIS SPECIFICATION, YOU ACCEPT THE TERMS AND CONDITIONS OF
+ * THE AGREEMENT. IF YOU ARE NOT WILLING TO BE BOUND BY IT, SELECT THE "DECLINE" BUTTON AT THE
+ * BOTTOM OF THIS PAGE. Specification: JSR-354 Money and Currency API ("Specification") Copyright
+ * (c) 2012-2013, Credit Suisse All rights reserved.
+ */
+package javax.money;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+
+import javax.money.internal.DefaultMonetaryAmountsSingletonQuerySpi;
+import javax.money.internal.DefaultMonetaryAmountsSingletonSpi;
+import javax.money.spi.Bootstrap;
+import javax.money.spi.MonetaryAmountsSingletonQuerySpi;
+import javax.money.spi.MonetaryAmountsSingletonSpi;
+import javax.money.spi.MonetaryCurrenciesSingletonSpi;
+import javax.money.spi.MonetaryRoundingsSingletonSpi;
+import javax.money.spi.RoundingProviderSpi;
+import javax.money.spi.ServiceProvider;
+
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.testng.annotations.Test;
+
+/**
+ * Test to ensure that singleton SPIs used by {@link Monetary} handle substitution of {@link ServiceProvider} to use when
+ * calling {@link Bootstrap#init(javax.money.spi.ServiceProvider)}. (e.g. in an OSGI environment)
+ * @author Matthias Hanisch
+ *
+ */
+public class MonetaryDynamicServiceProviderTest extends AbstractDynamicServiceProviderTest {
+    
+    
+    /**
+     * Default SPI: {@link DefaultMonetaryCurrenciesSingletonSpi} supports currencies test1 and test2.
+     * Dynamic SPI: Mock supporting currencies test1 and test3. 
+     * Testing following steps:
+     * <ul>
+     * <li>use default SPI</li>
+     * <li>currency test1 available</li>
+     * <li>currency test2 available</li>
+     * <li>currency test3 <b>not</b> available</li>
+     * <li>use dynamic SPI</li>
+     * <li>currency test1 available</li>
+     * <li>currency test2 <b>not</b> available</li>
+     * <li>currency test3 available</li>
+     * <li>use default SPI</li>
+     * <li>currency test1 available</li>
+     * <li>currency test2 available</li>
+     * <li>currency test3 <b>not</b> available</li>
+     * </ul>
+     * 
+     */
+    @Test
+    public void testMonetaryCurrenciesSingletonSpi() {
+        // DefaultMonetaryCurrenciesSingletonSpi is used
+        assertCurrencyAvailable("test1");
+        assertCurrencyAvailable("test2");
+        assertCurrencyMissing("test3");
+        MonetaryCurrenciesSingletonSpi mockSingleton = Mockito.mock(MonetaryCurrenciesSingletonSpi.class);
+        registerService(MonetaryCurrenciesSingletonSpi.class, mockSingleton);
+        doAnswer(new Answer<CurrencyUnit>() {
+            private List<String> supportedCurrencies = Arrays.asList("test1","test3");
+            @Override
+            public CurrencyUnit answer(InvocationOnMock invocation)
+                    throws Throwable {
+                String currencyCode =(String)invocation.getArguments()[0];
+                if(supportedCurrencies.contains(currencyCode)) {
+                    return new TestCurrency(currencyCode, 1,2);
+                }
+                throw new UnknownCurrencyException(currencyCode);
+            }
+        }).when(mockSingleton).getCurrency(anyString());
+        initTestServiceProvider();
+        // DynamicMonetaryCurrenciesSingletonSpi is used
+        assertCurrencyAvailable("test1");
+        assertCurrencyMissing("test2");
+        assertCurrencyAvailable("test3");
+        initOriginalServiceProvider();
+        // DefaultMonetaryCurrenciesSingletonSpi is used again
+        assertCurrencyAvailable("test1");
+        assertCurrencyAvailable("test2");
+        assertCurrencyMissing("test3");
+    }
+    
+    /**
+     * Default SPI: {@link DefaultMonetaryAmountsSingletonSpi} supports a {@link MonetaryAmountFactory} creating instances of DummyAmount.
+     * Dynamic SPI: Mock supporting a {@link MonetaryAmountFactory} creating a mocked {@link MonetaryAmount}
+     * Testing following steps:
+     * <ul>
+     * <li>use default SPI</li>
+     * <li>created MonetaryAmount should be a DummyAmount</li>
+     * <li>use dynamic SPI</li>
+     * <li>created MonetaryAmount should match the mocked Amount</li>
+     * <li>use default SPI</li>
+     * <li>created MonetaryAmount should be a DummyAmount</li>
+     * </ul>     
+     */
+    @Test
+    public void testMonetaryAmountsSingletonSpi() {
+        assertTrue(Monetary.getDefaultAmountFactory().create()instanceof DummyAmount);
+        MonetaryAmountsSingletonSpi mockSingleton = mock(MonetaryAmountsSingletonSpi.class);
+        MonetaryAmountFactory<?> mockFactory = mock(MonetaryAmountFactory.class);
+        MonetaryAmount mockAmount = mock(MonetaryAmount.class);
+        doReturn(mockFactory).when(mockSingleton).getDefaultAmountFactory();
+        doReturn(mockAmount).when(mockFactory).create();
+        registerService(MonetaryAmountsSingletonSpi.class, mockSingleton);
+        initTestServiceProvider();
+        assertFalse(Monetary.getDefaultAmountFactory().create()instanceof DummyAmount);
+        assertEquals(Monetary.getDefaultAmountFactory().create(), mockAmount);
+        initOriginalServiceProvider();
+        assertTrue(Monetary.getDefaultAmountFactory().create()instanceof DummyAmount);
+    }
+    
+    /**
+     * Default SPI: {@link DefaultMonetaryAmountsSingletonQuerySpi} supports {@link MonetaryAmountFactoryQuery} for DummyAmount.
+     * Dynamic SPI: Mock not supporting {@link MonetaryAmountFactoryQuery} for none MonetaryMount at all.
+     * Testing following steps:
+     * <ul>
+     * <li>use default SPI</li>
+     * <li>query for DummyAmount should be true</li>
+     * <li>use dynamic SPI</li>
+     * <li>query for DummyAmount should be false</li>
+     * <li>use default SPI</li>
+     * <li>query for DummyAmount should be true</li>
+     * </ul>
+     */
+    @Test
+    public void testMonetaryAmountsSingletonQuerySpi() {
+        MonetaryAmountFactoryQuery query = MonetaryAmountFactoryQueryBuilder.of()
+        .setTargetType(DummyAmount.class).build();
+        assertTrue(Monetary.isAvailable(query));
+        MonetaryAmountsSingletonQuerySpi mock= mock(MonetaryAmountsSingletonQuerySpi.class);
+        doReturn(Boolean.FALSE).when(mock).isAvailable(any(MonetaryAmountFactoryQuery.class));
+        registerService(MonetaryAmountsSingletonQuerySpi.class, mock);
+        initTestServiceProvider();
+        assertFalse(Monetary.isAvailable(query));
+        initOriginalServiceProvider();
+        assertTrue(Monetary.isAvailable(query));
+    }
+    
+    /**
+     * Default SPI: {@link DefaultMonetaryRoundingsSingletonSpi} uses {@link RoundingProviderSpi} supporting two rounding names.
+     * Dynamic SPI: Mock supporting one rounding name.
+     * Testing following steps:
+     * <ul>
+     * <li>use default SPI</li>
+     * <li>number of rounding names should be two</li>
+     * <li>use dynamic SPI</li>
+     * <li>number of rounding names should be one</li>
+     * <li>use default SPI</li>
+     * <li>number of rounding names should be two</li>
+     * </ul>
+     */
+    @Test
+    public void testMonetaryRoundingsSingletonSpi() {
+        assertEquals(Monetary.getRoundingNames().size(),2);
+        MonetaryRoundingsSingletonSpi mock = mock(MonetaryRoundingsSingletonSpi.class);
+        doReturn(new HashSet<>(Arrays.asList("dummyRounding"))).when(mock).getRoundingNames();
+        registerService(MonetaryRoundingsSingletonSpi.class, mock);
+        initTestServiceProvider();
+        assertEquals(Monetary.getRoundingNames().size(),1);
+        initOriginalServiceProvider();
+        assertEquals(Monetary.getRoundingNames().size(),2);
+    }
+    
+    private void assertCurrencyAvailable(String currency) {
+        CurrencyUnit cur = Monetary.getCurrency(currency);
+        assertNotNull(cur);
+    }
+    
+    private void assertCurrencyMissing(String currency) {
+        try {
+            CurrencyUnit cur = Monetary.getCurrency(currency);
+            fail(String.format("currency %s should not be available, but got %s", currency, cur));
+        } catch(UnknownCurrencyException ex) {
+            ex.printStackTrace();
+            // expected
+        }
+    }
+    
+
+}

src/test/java/javax/money/TestCurrency.java

@@ -55,7 +55,7 @@ public final class TestCurrency implements CurrencyUnit, Serializable, Comparabl
     /**
      * Private constructor.
      */
-    private TestCurrency(String code, int numCode, int fractionDigits) {
+    TestCurrency(String code, int numCode, int fractionDigits) {
         this.currencyCode = code;
         this.numericCode = numCode;
         this.defaultFractionDigits = fractionDigits;