New tests to cover more data types and optimistic locking. Also increments SDK dependency.

Author: SalusaSecondus

pom.xml

@@ -43,7 +43,7 @@
       <dependency>
         <groupId>com.amazonaws</groupId>
         <artifactId>aws-java-sdk-bom</artifactId>
-        <version>1.11.380</version>
+        <version>1.11.434</version>
         <type>pom</type>
         <scope>import</scope>
       </dependency>

src/test/java/com/amazonaws/services/dynamodbv2/datamodeling/TransformerHolisticTests.java

@@ -15,7 +15,10 @@
 package com.amazonaws.services.dynamodbv2.datamodeling;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import java.nio.ByteBuffer;
 import java.security.GeneralSecurityException;
@@ -34,6 +37,8 @@
 import javax.crypto.SecretKey;
 import javax.crypto.spec.SecretKeySpec;
 
+import com.amazonaws.ClientConfiguration;
+import com.amazonaws.services.dynamodbv2.model.ConditionalCheckFailedException;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -323,6 +328,75 @@ public void simpleSaveLoad() {
         assertNull(mapper.load(Mixed.class, 0, 15));
     }
 
+    /**
+     * This test ensures that optimistic locking can be successfully done through the {@link DynamoDBMapper} when
+     * combined with the @{link AttributeEncryptor}. Specifically it checks that {@link SaveBehavior#PUT} properly
+     * enforces versioning and will result in a {@link ConditionalCheckFailedException} when optimistic locking should
+     * prevent a write. Finally, it checks that {@link SaveBehavior#CLOBBER} properly ignores optimistic locking and
+     * overwrites the old value.
+     */
+    @Test
+    public void optimisticLockingTest() {
+        DynamoDBMapper mapper = new DynamoDBMapper(client,
+                                                   DynamoDBMapperConfig.builder()
+                                                                       .withSaveBehavior(SaveBehavior.PUT).build(),
+                                                   new AttributeEncryptor(symProv));
+        DynamoDBMapper clobberMapper = new DynamoDBMapper(client, CLOBBER_CONFIG, new AttributeEncryptor(symProv));
+
+        /*
+         * Lineage of objects
+         * expected -> v1 -> v2 -> v3
+         *                |
+         *                -> v2_2 -> clobbered
+         * Splitting the lineage after v1 is what should
+         * cause the ConditionalCheckFailedException.
+         */
+        final int hashKey = 0;
+        final int rangeKey = 15;
+        final Mixed expected = new Mixed();
+        expected.setHashKey(hashKey);
+        expected.setRangeKey(rangeKey);
+        expected.setIntSet(new HashSet<Integer>());
+        expected.getIntSet().add(3);
+        expected.getIntSet().add(5);
+        expected.getIntSet().add(7);
+        expected.setDoubleValue(15);
+        expected.setStringValue("Blargh!");
+        expected.setDoubleSet(
+                new HashSet<Double>(Arrays.asList(15.0D, 7.6D, -3D, -34.2D, 0.0D)));
+
+        mapper.save(expected);
+        Mixed v1 = mapper.load(Mixed.class, hashKey, rangeKey);
+        assertEquals(expected, v1);
+        v1.setStringValue("New value");
+        mapper.save(v1);
+        Mixed v2 = mapper.load(Mixed.class, hashKey, rangeKey);
+        assertEquals(v1, v2);
+        Mixed v2_2 = mapper.load(Mixed.class, hashKey, rangeKey);
+
+        v2.getIntSet().add(-37);
+        mapper.save(v2);
+        Mixed v3 = mapper.load(Mixed.class, hashKey, rangeKey);
+        assertEquals(v2, v3);
+        assertTrue(v3.getIntSet().contains(-37));
+
+        // This should fail due to optimistic locking
+        v2_2.getIntSet().add(38);
+        try {
+            mapper.save(v2_2);
+            fail("Expected ConditionalCheckFailedException");
+        } catch (ConditionalCheckFailedException ex) {
+            // Expected exception
+        }
+
+        // Force the update with clobber
+        clobberMapper.save(v2_2);
+        Mixed clobbered = mapper.load(Mixed.class, hashKey, rangeKey);
+        assertEquals(v2_2, clobbered);
+        assertTrue(clobbered.getIntSet().contains(38));
+        assertFalse(clobbered.getIntSet().contains(-37));
+    }
+
     @Test
     public void leadingAndTrailingZeros() {
         DynamoDBMapper mapper = new DynamoDBMapper(client, CLOBBER_CONFIG, new AttributeEncryptor(symProv));

src/test/java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptorTest.java

@@ -31,6 +31,7 @@
 import java.security.NoSuchProviderException;
 import java.security.Security;
 import java.security.SignatureException;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -96,6 +97,34 @@ public void setUp() throws Exception {
         attribs.put("rangeKey", new AttributeValue().withN("7"));
         attribs.put("version", new AttributeValue().withN("0"));
 
+        // New(er) data types
+        attribs.put("booleanTrue", new AttributeValue().withBOOL(true));
+        attribs.put("booleanFalse", new AttributeValue().withBOOL(false));
+        attribs.put("nullValue", new AttributeValue().withNULL(true));
+        Map<String, AttributeValue> tmpMap = new HashMap<>(attribs);
+        attribs.put("listValue", new AttributeValue().withL(
+                new AttributeValue().withS("I'm a string"),
+                new AttributeValue().withN("42"),
+                new AttributeValue().withS("Another string"),
+                new AttributeValue().withNS("1", "4", "7"),
+                new AttributeValue().withM(tmpMap),
+                new AttributeValue().withL(
+                        new AttributeValue().withN("123"),
+                        new AttributeValue().withNS("1", "200", "10", "15", "0"),
+                        new AttributeValue().withSS("Goodbye", "Cruel", "World", "!")
+                )));
+        tmpMap = new HashMap<>();
+        tmpMap.put("another string", new AttributeValue().withS("All around the cobbler's bench"));
+        tmpMap.put("next line", new AttributeValue().withSS("the monkey", "chased", "the weasel"));
+        tmpMap.put("more lyrics", new AttributeValue().withL(
+                new AttributeValue().withS("the monkey"),
+                new AttributeValue().withS("thought twas"),
+                new AttributeValue().withS("all in fun")
+        ));
+        tmpMap.put("weasel", new AttributeValue().withM(Collections.singletonMap("pop", new AttributeValue().withBOOL(true))));
+        attribs.put("song", new AttributeValue().withM(tmpMap));
+
+
         context = new EncryptionContext.Builder()
             .withTableName("TableName")
             .withHashKeyName("hashKey")

src/test/java/com/amazonaws/services/dynamodbv2/testing/AttrMatcher.java

@@ -60,13 +60,40 @@ public boolean matches(Object item) {
 
     public static boolean attrEquals(AttributeValue e, AttributeValue a) {
         if (!isEqual(e.getB(), a.getB()) ||
+                !isEqual(e.getBOOL(), a.getBOOL()) ||
+                !isSetEqual(e.getBS(), a.getBS()) ||
                 !isEqual(e.getN(), a.getN()) ||
+                !isSetEqual(e.getNS(), a.getNS()) ||
+                !isEqual(e.getNULL(), a.getNULL()) ||
                 !isEqual(e.getS(), a.getS()) ||
-                !isEqual(e.getBS(), a.getBS()) ||
-                !isEqual(e.getNS(), a.getNS()) ||
-                !isEqual(e.getSS(), a.getSS())) {
+                !isSetEqual(e.getSS(), a.getSS())) {
             return false;
         }
+        // Recursive types need special handling
+        if (e.getM() == null ^ a.getM() == null) {
+            return false;
+        } else if (e.getM() != null) {
+            if (!e.getM().keySet().equals(a.getM().keySet())) {
+                return false;
+            }
+            for (final String key : e.getM().keySet()) {
+                if (!attrEquals(e.getM().get(key), a.getM().get(key))) {
+                    return false;
+                }
+            }
+        }
+        if (e.getL() == null ^ a.getL() == null) {
+            return false;
+        } else if (e.getL() != null) {
+            if (e.getL().size() != a.getL().size()) {
+                return false;
+            }
+            for (int x = 0; x < e.getL().size(); x++) {
+                if (!attrEquals(e.getL().get(x), a.getL().get(x))) {
+                    return false;
+                }
+            }
+        }
         return true;
     }
 
@@ -82,7 +109,7 @@ private static boolean isEqual(Object o1, Object o2) {
         return o1.equals(o2);
     }
 
-    private static <T> boolean isEqual(Collection<T> c1, Collection<T> c2) {
+    private static <T> boolean isSetEqual(Collection<T> c1, Collection<T> c2) {
         if(c1 == null ^ c2 == null) {
             return false;
         }