Skip to content

Commit 59417d3

Browse files
tolbertamolim7t
tolbertam
authored and
olim7t
committed
Split CachingCodecRegistry tests for clarity
1 parent 0062d3f commit 59417d3

1 file changed

Lines changed: 127 additions & 21 deletions

File tree

‎core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/registry/CachingCodecRegistryTest.java‎

Lines changed: 127 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,9 @@
3939
import com.google.common.util.concurrent.UncheckedExecutionException;
4040
import java.math.BigDecimal;
4141
import java.math.BigInteger;
42+
import java.net.Inet4Address;
4243
import java.net.InetAddress;
44+
import java.net.UnknownHostException;
4345
import java.nio.ByteBuffer;
4446
import java.time.Instant;
4547
import java.time.LocalDate;
@@ -171,7 +173,7 @@ public void should_find_user_codec_for_custom_java_type() {
171173
}
172174

173175
@Test
174-
public void should_create_list_codec() {
176+
public void should_create_list_codec_for_cql_and_java_types() {
175177
ListType cqlType = DataTypes.listOf(DataTypes.listOf(DataTypes.INT));
176178
GenericType<List<List<Integer>>> javaType = new GenericType<List<List<Integer>>>() {};
177179
List<List<Integer>> value = ImmutableList.of(ImmutableList.of(1));
@@ -189,28 +191,46 @@ public void should_create_list_codec() {
189191
inOrder
190192
.verify(onCacheLookup)
191193
.accept(DataTypes.listOf(DataTypes.INT), GenericType.listOf(GenericType.INTEGER));
194+
}
195+
196+
@Test
197+
public void should_create_list_codec_for_cql_type() {
198+
ListType cqlType = DataTypes.listOf(DataTypes.listOf(DataTypes.INT));
199+
GenericType<List<List<Integer>>> javaType = new GenericType<List<List<Integer>>>() {};
200+
List<List<Integer>> value = ImmutableList.of(ImmutableList.of(1));
201+
202+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
203+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
192204

193-
codec = registry.codecFor(cqlType);
205+
TypeCodec<List<List<Integer>>> codec = registry.codecFor(cqlType);
194206
assertThat(codec).isNotNull();
195207
assertThat(codec.canDecode(cqlType)).isTrue();
196208
assertThat(codec.canEncode(javaType)).isTrue();
197209
assertThat(codec.canEncode(value)).isTrue();
198210
inOrder.verify(onCacheLookup).accept(cqlType, null);
199211
inOrder.verify(onCacheLookup).accept(DataTypes.listOf(DataTypes.INT), null);
212+
}
200213

201-
codec = registry.codecFor(value);
214+
@Test
215+
public void should_create_list_codec_for_java_value() throws UnknownHostException {
216+
ListType cqlType = DataTypes.listOf(DataTypes.listOf(DataTypes.INT));
217+
GenericType<List<List<Integer>>> javaType = new GenericType<List<List<Integer>>>() {};
218+
List<List<Integer>> value = ImmutableList.of(ImmutableList.of(1));
219+
220+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
221+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
222+
223+
TypeCodec<List<List<Integer>>> codec = registry.codecFor(value);
202224
assertThat(codec).isNotNull();
203225
assertThat(codec.canDecode(cqlType)).isTrue();
204226
assertThat(codec.canEncode(javaType)).isTrue();
205227
assertThat(codec.canEncode(value)).isTrue();
206228
inOrder.verify(onCacheLookup).accept(null, javaType);
207229
inOrder.verify(onCacheLookup).accept(null, GenericType.listOf(GenericType.INTEGER));
208-
209-
inOrder.verifyNoMoreInteractions();
210230
}
211231

212232
@Test
213-
public void should_create_set_codec() {
233+
public void should_create_set_codec_for_cql_and_java_types() {
214234
SetType cqlType = DataTypes.setOf(DataTypes.setOf(DataTypes.INT));
215235
GenericType<Set<Set<Integer>>> javaType = new GenericType<Set<Set<Integer>>>() {};
216236
Set<Set<Integer>> value = ImmutableSet.of(ImmutableSet.of(1));
@@ -228,28 +248,46 @@ public void should_create_set_codec() {
228248
inOrder
229249
.verify(onCacheLookup)
230250
.accept(DataTypes.setOf(DataTypes.INT), GenericType.setOf(GenericType.INTEGER));
251+
}
231252

232-
codec = registry.codecFor(cqlType);
253+
@Test
254+
public void should_create_set_codec_for_cql_type() {
255+
SetType cqlType = DataTypes.setOf(DataTypes.setOf(DataTypes.INT));
256+
GenericType<Set<Set<Integer>>> javaType = new GenericType<Set<Set<Integer>>>() {};
257+
Set<Set<Integer>> value = ImmutableSet.of(ImmutableSet.of(1));
258+
259+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
260+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
261+
262+
TypeCodec<Set<Set<Integer>>> codec = registry.codecFor(cqlType);
233263
assertThat(codec).isNotNull();
234264
assertThat(codec.canDecode(cqlType)).isTrue();
235265
assertThat(codec.canEncode(javaType)).isTrue();
236266
assertThat(codec.canEncode(value)).isTrue();
237267
inOrder.verify(onCacheLookup).accept(cqlType, null);
238268
inOrder.verify(onCacheLookup).accept(DataTypes.setOf(DataTypes.INT), null);
269+
}
239270

240-
codec = registry.codecFor(value);
271+
@Test
272+
public void should_create_set_codec_for_java_value() {
273+
SetType cqlType = DataTypes.setOf(DataTypes.setOf(DataTypes.INT));
274+
GenericType<Set<Set<Integer>>> javaType = new GenericType<Set<Set<Integer>>>() {};
275+
Set<Set<Integer>> value = ImmutableSet.of(ImmutableSet.of(1));
276+
277+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
278+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
279+
280+
TypeCodec<Set<Set<Integer>>> codec = registry.codecFor(value);
241281
assertThat(codec).isNotNull();
242282
assertThat(codec.canDecode(cqlType)).isTrue();
243283
assertThat(codec.canEncode(javaType)).isTrue();
244284
assertThat(codec.canEncode(value)).isTrue();
245285
inOrder.verify(onCacheLookup).accept(null, javaType);
246286
inOrder.verify(onCacheLookup).accept(null, GenericType.setOf(GenericType.INTEGER));
247-
248-
inOrder.verifyNoMoreInteractions();
249287
}
250288

251289
@Test
252-
public void should_create_map_codec() {
290+
public void should_create_map_codec_for_cql_and_java_types() {
253291
MapType cqlType = DataTypes.mapOf(DataTypes.INT, DataTypes.mapOf(DataTypes.INT, DataTypes.INT));
254292
GenericType<Map<Integer, Map<Integer, Integer>>> javaType =
255293
new GenericType<Map<Integer, Map<Integer, Integer>>>() {};
@@ -270,16 +308,38 @@ public void should_create_map_codec() {
270308
.accept(
271309
DataTypes.mapOf(DataTypes.INT, DataTypes.INT),
272310
GenericType.mapOf(GenericType.INTEGER, GenericType.INTEGER));
311+
}
312+
313+
@Test
314+
public void should_create_map_codec_for_cql_type() {
315+
MapType cqlType = DataTypes.mapOf(DataTypes.INT, DataTypes.mapOf(DataTypes.INT, DataTypes.INT));
316+
GenericType<Map<Integer, Map<Integer, Integer>>> javaType =
317+
new GenericType<Map<Integer, Map<Integer, Integer>>>() {};
318+
Map<Integer, Map<Integer, Integer>> value = ImmutableMap.of(1, ImmutableMap.of(1, 1));
273319

274-
codec = registry.codecFor(cqlType);
320+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
321+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
322+
323+
TypeCodec<Map<Integer, Map<Integer, Integer>>> codec = registry.codecFor(cqlType);
275324
assertThat(codec).isNotNull();
276325
assertThat(codec.canDecode(cqlType)).isTrue();
277326
assertThat(codec.canEncode(javaType)).isTrue();
278327
assertThat(codec.canEncode(value)).isTrue();
279328
inOrder.verify(onCacheLookup).accept(cqlType, null);
280329
inOrder.verify(onCacheLookup).accept(DataTypes.mapOf(DataTypes.INT, DataTypes.INT), null);
330+
}
331+
332+
@Test
333+
public void should_create_map_codec_for_java_value() {
334+
MapType cqlType = DataTypes.mapOf(DataTypes.INT, DataTypes.mapOf(DataTypes.INT, DataTypes.INT));
335+
GenericType<Map<Integer, Map<Integer, Integer>>> javaType =
336+
new GenericType<Map<Integer, Map<Integer, Integer>>>() {};
337+
Map<Integer, Map<Integer, Integer>> value = ImmutableMap.of(1, ImmutableMap.of(1, 1));
338+
339+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
340+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
281341

282-
codec = registry.codecFor(value);
342+
TypeCodec<Map<Integer, Map<Integer, Integer>>> codec = registry.codecFor(value);
283343
assertThat(codec).isNotNull();
284344
assertThat(codec.canDecode(cqlType)).isTrue();
285345
assertThat(codec.canEncode(javaType)).isTrue();
@@ -288,12 +348,10 @@ public void should_create_map_codec() {
288348
inOrder
289349
.verify(onCacheLookup)
290350
.accept(null, GenericType.mapOf(GenericType.INTEGER, GenericType.INTEGER));
291-
292-
inOrder.verifyNoMoreInteractions();
293351
}
294352

295353
@Test
296-
public void should_create_tuple_codec() {
354+
public void should_create_tuple_codec_for_cql_and_java_types() {
297355
TupleType cqlType = DataTypes.tupleOf(DataTypes.INT, DataTypes.listOf(DataTypes.TEXT));
298356
TupleValue value = cqlType.newValue();
299357

@@ -309,15 +367,34 @@ public void should_create_tuple_codec() {
309367
inOrder.verify(onCacheLookup).accept(cqlType, GenericType.TUPLE_VALUE);
310368
// field codecs are only looked up when fields are accessed, so no cache hit for list<int> now
311369

312-
codec = registry.codecFor(cqlType);
370+
}
371+
372+
@Test
373+
public void should_create_tuple_codec_for_cql_type() {
374+
TupleType cqlType = DataTypes.tupleOf(DataTypes.INT, DataTypes.listOf(DataTypes.TEXT));
375+
TupleValue value = cqlType.newValue();
376+
377+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
378+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
379+
380+
TypeCodec<TupleValue> codec = registry.codecFor(cqlType);
313381
assertThat(codec).isNotNull();
314382
assertThat(codec.canDecode(cqlType)).isTrue();
315383
assertThat(codec.canEncode(GenericType.TUPLE_VALUE)).isTrue();
316384
assertThat(codec.canEncode(TupleValue.class)).isTrue();
317385
assertThat(codec.canEncode(value)).isTrue();
318386
inOrder.verify(onCacheLookup).accept(cqlType, null);
387+
}
319388

320-
codec = registry.codecFor(value);
389+
@Test
390+
public void should_create_tuple_codec_for_java_value() {
391+
TupleType cqlType = DataTypes.tupleOf(DataTypes.INT, DataTypes.listOf(DataTypes.TEXT));
392+
TupleValue value = cqlType.newValue();
393+
394+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
395+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
396+
397+
TypeCodec<TupleValue> codec = registry.codecFor(value);
321398
assertThat(codec).isNotNull();
322399
assertThat(codec.canDecode(cqlType)).isTrue();
323400
assertThat(codec.canEncode(GenericType.TUPLE_VALUE)).isTrue();
@@ -329,7 +406,7 @@ public void should_create_tuple_codec() {
329406
}
330407

331408
@Test
332-
public void should_create_udt_codec() {
409+
public void should_create_udt_codec_for_cql_and_java_types() {
333410
UserDefinedType cqlType =
334411
new UserDefinedTypeBuilder(
335412
CqlIdentifier.fromInternal("ks"), CqlIdentifier.fromInternal("type"))
@@ -350,15 +427,44 @@ public void should_create_udt_codec() {
350427
inOrder.verify(onCacheLookup).accept(cqlType, GenericType.UDT_VALUE);
351428
// field codecs are only looked up when fields are accessed, so no cache hit for list<int> now
352429

353-
codec = registry.codecFor(cqlType);
430+
}
431+
432+
@Test
433+
public void should_create_udt_codec_for_cql_type() {
434+
UserDefinedType cqlType =
435+
new UserDefinedTypeBuilder(
436+
CqlIdentifier.fromInternal("ks"), CqlIdentifier.fromInternal("type"))
437+
.withField(CqlIdentifier.fromInternal("field1"), DataTypes.INT)
438+
.withField(CqlIdentifier.fromInternal("field2"), DataTypes.listOf(DataTypes.TEXT))
439+
.build();
440+
UdtValue value = cqlType.newValue();
441+
442+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
443+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
444+
445+
TypeCodec<UdtValue> codec = registry.codecFor(cqlType);
354446
assertThat(codec).isNotNull();
355447
assertThat(codec.canDecode(cqlType)).isTrue();
356448
assertThat(codec.canEncode(GenericType.UDT_VALUE)).isTrue();
357449
assertThat(codec.canEncode(UdtValue.class)).isTrue();
358450
assertThat(codec.canEncode(value)).isTrue();
359451
inOrder.verify(onCacheLookup).accept(cqlType, null);
452+
}
453+
454+
@Test
455+
public void should_create_udt_codec_for_java_value() {
456+
UserDefinedType cqlType =
457+
new UserDefinedTypeBuilder(
458+
CqlIdentifier.fromInternal("ks"), CqlIdentifier.fromInternal("type"))
459+
.withField(CqlIdentifier.fromInternal("field1"), DataTypes.INT)
460+
.withField(CqlIdentifier.fromInternal("field2"), DataTypes.listOf(DataTypes.TEXT))
461+
.build();
462+
UdtValue value = cqlType.newValue();
463+
464+
TestCachingCodecRegistry registry = new TestCachingCodecRegistry(onCacheLookup);
465+
InOrder inOrder = Mockito.inOrder(onCacheLookup);
360466

361-
codec = registry.codecFor(value);
467+
TypeCodec<UdtValue> codec = registry.codecFor(value);
362468
assertThat(codec).isNotNull();
363469
assertThat(codec.canDecode(cqlType)).isTrue();
364470
assertThat(codec.canEncode(GenericType.UDT_VALUE)).isTrue();

0 commit comments

Comments
 (0)