From b0873d29b62c997fb38f6dc9f29dfdcf73c79c66 Mon Sep 17 00:00:00 2001 From: Mark Paluch Date: Tue, 24 Apr 2018 11:51:25 +0200 Subject: [PATCH] DATAREDIS-786 - Polishing. Reformat test code. Original Pull Request: #334 --- .../core/DefaultValueOperationsTests.java | 216 ++++++++++++------ 1 file changed, 145 insertions(+), 71 deletions(-) diff --git a/src/test/java/org/springframework/data/redis/core/DefaultValueOperationsTests.java b/src/test/java/org/springframework/data/redis/core/DefaultValueOperationsTests.java index d2786e59c..53f000692 100644 --- a/src/test/java/org/springframework/data/redis/core/DefaultValueOperationsTests.java +++ b/src/test/java/org/springframework/data/redis/core/DefaultValueOperationsTests.java @@ -97,186 +97,249 @@ public class DefaultValueOperationsTests { @Test // DATAREDIS-784 public void testIncrement() { + K key = keyFactory.instance(); - V v1 = valueFactory.instance(); - assumeTrue(v1 instanceof Long); - valueOps.set(key, v1); - assertEquals(Long.valueOf((Long) v1 + 1), valueOps.increment(key)); - assertEquals(Long.valueOf((Long) v1 + 1), valueOps.get(key)); + V value = valueFactory.instance(); + + assumeTrue(value instanceof Long); + + valueOps.set(key, value); + + assertEquals(Long.valueOf((Long) value + 1), valueOps.increment(key)); + assertEquals(Long.valueOf((Long) value + 1), valueOps.get(key)); } @Test public void testIncrementLong() { + K key = keyFactory.instance(); - V v1 = valueFactory.instance(); - assumeTrue(v1 instanceof Long); - valueOps.set(key, v1); - assertEquals(Long.valueOf((Long) v1 - 10), valueOps.increment(key, -10)); - assertEquals(Long.valueOf((Long) v1 - 10), (Long) valueOps.get(key)); + V value = valueFactory.instance(); + + assumeTrue(value instanceof Long); + + valueOps.set(key, value); + + assertEquals(Long.valueOf((Long) value - 10), valueOps.increment(key, -10)); + assertEquals(Long.valueOf((Long) value - 10), valueOps.get(key)); + valueOps.increment(key, -10); - assertEquals(Long.valueOf((Long) v1 - 20), (Long) valueOps.get(key)); + assertEquals(Long.valueOf((Long) value - 20), valueOps.get(key)); } @Test // DATAREDIS-247 public void testIncrementDouble() { assumeTrue(RedisTestProfileValueSource.matches("redisVersion", "2.6")); + K key = keyFactory.instance(); - V v1 = valueFactory.instance(); - assumeTrue(v1 instanceof Double); - valueOps.set(key, v1); + V value = valueFactory.instance(); + + assumeTrue(value instanceof Double); + + valueOps.set(key, value); + DecimalFormat twoDForm = (DecimalFormat) DecimalFormat.getInstance(Locale.US); - assertEquals(Double.valueOf(twoDForm.format((Double) v1 + 1.4)), valueOps.increment(key, 1.4)); - assertEquals(Double.valueOf(twoDForm.format((Double) v1 + 1.4)), valueOps.get(key)); + assertEquals(Double.valueOf(twoDForm.format((Double) value + 1.4)), valueOps.increment(key, 1.4)); + assertEquals(Double.valueOf(twoDForm.format((Double) value + 1.4)), valueOps.get(key)); + valueOps.increment(key, -10d); - assertEquals(Double.valueOf(twoDForm.format((Double) v1 + 1.4 - 10d)), valueOps.get(key)); + assertEquals(Double.valueOf(twoDForm.format((Double) value + 1.4 - 10d)), valueOps.get(key)); } @Test // DATAREDIS-784 public void testDecrement() { + K key = keyFactory.instance(); - V v1 = valueFactory.instance(); - assumeTrue(v1 instanceof Long); - valueOps.set(key, v1); - assertEquals(Long.valueOf((Long) v1 - 1), valueOps.decrement(key)); - assertEquals(Long.valueOf((Long) v1 - 1), valueOps.get(key)); + V value = valueFactory.instance(); + + assumeTrue(value instanceof Long); + + valueOps.set(key, value); + + assertEquals(Long.valueOf((Long) value - 1), valueOps.decrement(key)); + assertEquals(Long.valueOf((Long) value - 1), valueOps.get(key)); } @Test // DATAREDIS-784 public void testDecrementByLong() { + K key = keyFactory.instance(); - V v1 = valueFactory.instance(); - assumeTrue(v1 instanceof Long); - valueOps.set(key, v1); - assertEquals(Long.valueOf((Long) v1 - 5), valueOps.decrement(key, 5)); - assertEquals(Long.valueOf((Long) v1 - 5), valueOps.get(key)); + V value = valueFactory.instance(); + + assumeTrue(value instanceof Long); + + valueOps.set(key, value); + + assertEquals(Long.valueOf((Long) value - 5), valueOps.decrement(key, 5)); + assertEquals(Long.valueOf((Long) value - 5), valueOps.get(key)); } @Test public void testMultiSetIfAbsent() { + Map keysAndValues = new HashMap<>(); K key1 = keyFactory.instance(); K key2 = keyFactory.instance(); V value1 = valueFactory.instance(); V value2 = valueFactory.instance(); + keysAndValues.put(key1, value1); keysAndValues.put(key2, value2); + assertTrue(valueOps.multiSetIfAbsent(keysAndValues)); assertThat(valueOps.multiGet(keysAndValues.keySet()), isEqual(new ArrayList<>(keysAndValues.values()))); } @Test public void testMultiSetIfAbsentFailure() { + K key1 = keyFactory.instance(); K key2 = keyFactory.instance(); V value1 = valueFactory.instance(); V value2 = valueFactory.instance(); V value3 = valueFactory.instance(); + valueOps.set(key1, value1); + Map keysAndValues = new HashMap<>(); keysAndValues.put(key1, value2); keysAndValues.put(key2, value3); + assertFalse(valueOps.multiSetIfAbsent(keysAndValues)); } @Test public void testMultiSet() { + Map keysAndValues = new HashMap<>(); K key1 = keyFactory.instance(); K key2 = keyFactory.instance(); V value1 = valueFactory.instance(); V value2 = valueFactory.instance(); + keysAndValues.put(key1, value1); keysAndValues.put(key2, value2); + valueOps.multiSet(keysAndValues); + assertThat(valueOps.multiGet(keysAndValues.keySet()), isEqual(new ArrayList<>(keysAndValues.values()))); } @Test public void testGetSet() { - K key1 = keyFactory.instance(); - V value1 = valueFactory.instance(); - valueOps.set(key1, value1); - assertThat(valueOps.get(key1), isEqual(value1)); + + K key = keyFactory.instance(); + V value = valueFactory.instance(); + + valueOps.set(key, value); + + assertThat(valueOps.get(key), isEqual(value)); } @Test public void testGetAndSet() { - K key1 = keyFactory.instance(); + + K key = keyFactory.instance(); V value1 = valueFactory.instance(); V value2 = valueFactory.instance(); - valueOps.set(key1, value1); - assertThat(valueOps.getAndSet(key1, value2), isEqual(value1)); + + valueOps.set(key, value1); + + assertThat(valueOps.getAndSet(key, value2), isEqual(value1)); } @Test public void testSetWithExpiration() { + assumeTrue(RedisTestProfileValueSource.matches("runLongTests", "true")); - final K key1 = keyFactory.instance(); - V value1 = valueFactory.instance(); - valueOps.set(key1, value1, 1, TimeUnit.SECONDS); - waitFor(() -> (!redisTemplate.hasKey(key1)), 1000); + + K key = keyFactory.instance(); + V value = valueFactory.instance(); + + valueOps.set(key, value, 1, TimeUnit.SECONDS); + + waitFor(() -> (!redisTemplate.hasKey(key)), 1000); } @Test // DATAREDIS-271 public void testSetWithExpirationWithTimeUnitMilliseconds() { assumeTrue(RedisTestProfileValueSource.matches("runLongTests", "true")); - final K key1 = keyFactory.instance(); - V value1 = valueFactory.instance(); - valueOps.set(key1, value1, 1, TimeUnit.MILLISECONDS); - waitFor(() -> (!redisTemplate.hasKey(key1)), 500); + + K key = keyFactory.instance(); + V value = valueFactory.instance(); + + valueOps.set(key, value, 1, TimeUnit.MILLISECONDS); + + waitFor(() -> (!redisTemplate.hasKey(key)), 500); } @Test public void testAppend() { - K key1 = keyFactory.instance(); - V value1 = valueFactory.instance(); + + K key = keyFactory.instance(); + V value = valueFactory.instance(); + assumeTrue(redisTemplate instanceof StringRedisTemplate); - valueOps.set(key1, value1); - assertEquals(Integer.valueOf(((String) value1).length() + 3), valueOps.append(key1, "aaa")); - assertEquals((String) value1 + "aaa", valueOps.get(key1)); + + valueOps.set(key, value); + + assertEquals(Integer.valueOf(((String) value).length() + 3), valueOps.append(key, "aaa")); + assertEquals((String) value + "aaa", valueOps.get(key)); } @Test public void testGetRange() { - K key1 = keyFactory.instance(); - V value1 = valueFactory.instance(); - assumeTrue(value1 instanceof String); - valueOps.set(key1, value1); - assertEquals(2, valueOps.get(key1, 0, 1).length()); + + K key = keyFactory.instance(); + V value = valueFactory.instance(); + + assumeTrue(value instanceof String); + + valueOps.set(key, value); + + assertEquals(2, valueOps.get(key, 0, 1).length()); } @Test public void testSetRange() { - K key1 = keyFactory.instance(); + + K key = keyFactory.instance(); V value1 = valueFactory.instance(); V value2 = valueFactory.instance(); + assumeTrue(value1 instanceof String); - valueOps.set(key1, value1); - valueOps.set(key1, value2, 0); - assertEquals(value2, valueOps.get(key1)); + + valueOps.set(key, value1); + valueOps.set(key, value2, 0); + + assertEquals(value2, valueOps.get(key)); } @Test public void testSetIfAbsent() { - K key1 = keyFactory.instance(); + + K key = keyFactory.instance(); V value1 = valueFactory.instance(); V value2 = valueFactory.instance(); - assertTrue(valueOps.setIfAbsent(key1, value1)); - assertFalse(valueOps.setIfAbsent(key1, value2)); + + assertTrue(valueOps.setIfAbsent(key, value1)); + assertFalse(valueOps.setIfAbsent(key, value2)); } @Test // DATAREDIS-782 public void testSetIfAbsentWithExpiration() { + K key = keyFactory.instance(); V value1 = valueFactory.instance(); V value2 = valueFactory.instance(); + assertTrue(valueOps.setIfAbsent(key, value1, 5, TimeUnit.SECONDS)); - assertFalse(valueOps.setIfAbsent(key, value2)); assertFalse(valueOps.setIfAbsent(key, value2, 5, TimeUnit.SECONDS)); + Long expire = redisTemplate.getExpire(key, TimeUnit.MILLISECONDS); + assertThat(expire, is(lessThan(TimeUnit.SECONDS.toMillis(6)))); assertThat(expire, is(greaterThan(TimeUnit.MILLISECONDS.toMillis(1)))); } @@ -315,36 +378,48 @@ public class DefaultValueOperationsTests { @Test public void testSize() { - K key1 = keyFactory.instance(); - V value1 = valueFactory.instance(); - valueOps.set(key1, value1); - assertTrue(valueOps.size(key1) > 0); + + K key = keyFactory.instance(); + V value = valueFactory.instance(); + + valueOps.set(key, value); + + assertTrue(valueOps.size(key) > 0); } @SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testRawKeys() { + K key1 = keyFactory.instance(); K key2 = keyFactory.instance(); + byte[][] rawKeys = ((DefaultValueOperations) valueOps).rawKeys(key1, key2); + assertEquals(2, rawKeys.length); } @SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testRawKeysCollection() { + K key1 = keyFactory.instance(); K key2 = keyFactory.instance(); + byte[][] rawKeys = ((DefaultValueOperations) valueOps).rawKeys(Arrays.asList(new Object[] { key1, key2 })); + assertEquals(2, rawKeys.length); } @SuppressWarnings("rawtypes") @Test public void testDeserializeKey() { - K key1 = keyFactory.instance(); - assumeTrue(key1 instanceof byte[]); - assertNotNull(((DefaultValueOperations) valueOps).deserializeKey((byte[]) key1)); + + K key = keyFactory.instance(); + + assumeTrue(key instanceof byte[]); + + assertNotNull(((DefaultValueOperations) valueOps).deserializeKey((byte[]) key)); } @Test // DATAREDIS-197 @@ -352,11 +427,10 @@ public class DefaultValueOperationsTests { assumeTrue(redisTemplate instanceof StringRedisTemplate); - K key1 = keyFactory.instance(); + K key = keyFactory.instance(); int bitOffset = 65; - valueOps.setBit(key1, bitOffset, true); + valueOps.setBit(key, bitOffset, true); - assertEquals(true, valueOps.getBit(key1, bitOffset)); + assertEquals(true, valueOps.getBit(key, bitOffset)); } - }