feat: Parameters injection

powertools-parameters/pom.xml

@@ -82,7 +82,10 @@
             <artifactId>aspectjrt</artifactId>
             <scope>compile</scope>
         </dependency>
-
+        <dependency>
+            <groupId>software.amazon.payloadoffloading</groupId>
+            <artifactId>payloadoffloading-common</artifactId>
+        </dependency>
         <!-- Test dependencies -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -99,6 +102,11 @@
             <artifactId>mockito-core</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-inline</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>

powertools-parameters/src/main/java/software/amazon/lambda/powertools/parameters/ParamManager.java

@@ -13,10 +13,11 @@
  */
 package software.amazon.lambda.powertools.parameters;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
 import software.amazon.awssdk.services.ssm.SsmClient;
 import software.amazon.lambda.powertools.parameters.cache.CacheManager;
-import software.amazon.lambda.powertools.parameters.exception.ProviderException;
 import software.amazon.lambda.powertools.parameters.transform.TransformationManager;
 
 import java.lang.reflect.Constructor;
@@ -29,6 +30,8 @@
  */
 public final class ParamManager {
 
+    private static final Log LOG = LogFactory.getLog(ParamManager.class);
+
     private static final CacheManager cacheManager = new CacheManager();
     private static final TransformationManager transformationManager = new TransformationManager();
 
@@ -42,20 +45,9 @@ public final class ParamManager {
      */
     public static <T extends BaseProvider> T getProvider(Class<T> providerClass) {
         if (providerClass == null) {
-            throw new IllegalStateException("You cannot provide a null provider class.");
-        }
-        try {
-
-            if(!providers.containsKey(providerClass)) {
-                Constructor<T> constructor = providerClass.getDeclaredConstructor(CacheManager.class);
-                T provider = constructor.newInstance(cacheManager);
-                provider.setTransformationManager(transformationManager);
-                providers.putIfAbsent(providerClass, provider);
-            }
-            return (T) providers.get(providerClass);
-        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
-            throw new ProviderException(e);
+            throw new IllegalStateException("providerClass cannot be null.");
         }
+        return (T) providers.computeIfAbsent(providerClass, (k) -> createProvider(k));
     }
 
     /**
@@ -82,14 +74,11 @@ public static SSMProvider getSsmProvider() {
      * @return a {@link SecretsProvider}
      */
     public static SecretsProvider getSecretsProvider(SecretsManagerClient client) {
-        if (!providers.containsKey(SecretsProvider.class)) {
-            providers.putIfAbsent(SecretsProvider.class, SecretsProvider.builder()
-                                    .withClient(client)
-                                    .withCacheManager(cacheManager)
-                                    .withTransformationManager(transformationManager)
-                                    .build());
-        }
-        return (SecretsProvider) providers.get(SecretsProvider.class);
+        return (SecretsProvider) providers.computeIfAbsent(SecretsProvider.class, (k) -> SecretsProvider.builder()
+                .withClient(client)
+                .withCacheManager(cacheManager)
+                .withTransformationManager(transformationManager)
+                .build());
     }
 
     /**
@@ -98,14 +87,11 @@ public static SecretsProvider getSecretsProvider(SecretsManagerClient client) {
      * @return a {@link SSMProvider}
      */
     public static SSMProvider getSsmProvider(SsmClient client) {
-        if (!providers.containsKey(SSMProvider.class)) {
-            providers.putIfAbsent(SSMProvider.class, SSMProvider.builder()
-                    .withClient(client)
-                    .withCacheManager(cacheManager)
-                    .withTransformationManager(transformationManager)
-                    .build());
-        }
-        return (SSMProvider) providers.get(SSMProvider.class);
+        return (SSMProvider) providers.computeIfAbsent(SSMProvider.class, (k) -> SSMProvider.builder()
+                .withClient(client)
+                .withCacheManager(cacheManager)
+                .withTransformationManager(transformationManager)
+                .build());
     }
 
     public static CacheManager getCacheManager() {
@@ -115,4 +101,18 @@ public static CacheManager getCacheManager() {
     public static TransformationManager getTransformationManager() {
         return transformationManager;
     }
+
+    private static <T extends BaseProvider> T createProvider(Class<T> providerClass) {
+        try {
+            Constructor<T> constructor = providerClass.getDeclaredConstructor(CacheManager.class);
+            T provider = constructor.newInstance(cacheManager);
+            provider.setTransformationManager(transformationManager);
+            return provider;
+        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
+            LOG.error("Failed creating provider instance", e);
+            throw new RuntimeException("Unexpected error occurred. Please raise issue at " +
+                    "https://github.com/awslabs/aws-lambda-powertools-java/issues", e);
+        }
+    }
+
 }

powertools-parameters/src/main/java/software/amazon/lambda/powertools/parameters/internal/LambdaParametersAspect.java

@@ -16,10 +16,11 @@ public void getParam(Param paramAnnotation) {
 
     @Around("getParam(paramAnnotation)")
     public Object injectParam(final ProceedingJoinPoint joinPoint, final Param paramAnnotation) {
-        BaseProvider provider = ParamManager.getProvider(paramAnnotation.provider());
-        if(null == provider) {
-            throw new IllegalArgumentException(String.format("ParamProvider %s not supported.", paramAnnotation.provider().getName()));
+        if(null == paramAnnotation.provider()) {
+            throw new IllegalArgumentException("provider for Param annotation cannot be null!");
         }
+        BaseProvider provider = ParamManager.getProvider(paramAnnotation.provider());
+
         if(paramAnnotation.transformer().isInterface()) {
             // No transformation
             return provider.get(paramAnnotation.key());

powertools-parameters/src/test/java/software/amazon/lambda/powertools/parameters/internal/LambdaParametersAspectTest.java

@@ -1,17 +1,30 @@
 package software.amazon.lambda.powertools.parameters.internal;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import software.amazon.lambda.powertools.parameters.Param;
+import software.amazon.lambda.powertools.parameters.ParamManager;
+import software.amazon.lambda.powertools.parameters.SSMProvider;
 import software.amazon.lambda.powertools.parameters.exception.TransformationException;
 import software.amazon.lambda.powertools.parameters.transform.Base64Transformer;
 import software.amazon.lambda.powertools.parameters.transform.JsonTransformer;
 import software.amazon.lambda.powertools.parameters.transform.ObjectToDeserialize;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.Mockito.*;
+import static org.mockito.MockitoAnnotations.openMocks;
 
 public class LambdaParametersAspectTest {
 
+    @Mock
+    private SSMProvider defaultProvider;
+
+    @Param(key = "/default")
+    private String defaultValue;
+
     @Param(key = "/simple", provider = CustomProvider.class)
     private String param;
 
@@ -24,28 +37,43 @@ public class LambdaParametersAspectTest {
     @Param(key = "/json", provider = CustomProvider.class, transformer = JsonTransformer.class)
     private AnotherObject wrongTransform;
 
+    @BeforeEach
+    public void init() {
+        openMocks(this);
+    }
+
     @Test
-    public void testSimple() {
-        String paramValue = param;
+    public void testDefault_ShouldUseSSMProvider() {
+        try (MockedStatic<ParamManager> mocked = mockStatic(ParamManager.class)) {
+            mocked.when(() -> ParamManager.getProvider(SSMProvider.class)).thenReturn(defaultProvider);
+            when(defaultProvider.get("/default")).thenReturn("value");
 
-        assertThat(paramValue).isEqualTo("value");
+            assertThat(defaultValue).isEqualTo("value");
+            mocked.verify(times(1), () -> ParamManager.getProvider(SSMProvider.class));
+            verify(defaultProvider, times(1)).get("/default");
+
+            mocked.reset();
+        }
+    }
+
+    @Test
+    public void testSimple() {
+        assertThat(param).isEqualTo("value");
     }
 
     @Test
     public void testWithBasicTransform() {
-        String paramValue = basicTransform;
-        assertThat(paramValue).isEqualTo("value");
+        assertThat(basicTransform).isEqualTo("value");
     }
 
     @Test
     public void testWithComplexTransform() {
-        ObjectToDeserialize paramValue = complexTransform;
-        assertThat(paramValue).isNotNull();
-        assertThat(paramValue).isInstanceOf(ObjectToDeserialize.class);
-        assertThat(paramValue).matches(
-                o -> o.getFoo().equals("Foo") &&
-                o.getBar() == 42 &&
-                o.getBaz() == 123456789);
+        assertThat(complexTransform)
+                .isInstanceOf(ObjectToDeserialize.class)
+                .matches(
+                        o -> o.getFoo().equals("Foo") &&
+                        o.getBar() == 42 &&
+                        o.getBaz() == 123456789);
     }
 
     @Test