storage-units-mongodb/src/test/java/de/xn__ho_hia/storage_unit/mongodb/StorageUnitCodecTest.java

   1 /*
   2  * This file is part of storage-units. It is subject to the license terms in the LICENSE file found in the top-level
   3  * directory of this distribution and at http://creativecommons.org/publicdomain/zero/1.0/. No part of storage-units,
   4  * including this file, may be copied, modified, propagated, or distributed except according to the terms contained
   5  * in the LICENSE file.
   6  */
   7 package de.xn__ho_hia.storage_unit.mongodb;
   8
   9 import java.util.ArrayList;
  10 import java.util.List;
  11 import java.util.function.Supplier;
  12
  13 import org.bson.BsonReader;
  14 import org.bson.BsonWriter;
  15 import org.bson.codecs.DecoderContext;
  16 import org.bson.codecs.EncoderContext;
  17 import org.jooq.lambda.tuple.Tuple2;
  18 import org.junit.Assert;
  19 import org.junit.experimental.theories.DataPoints;
  20 import org.junit.experimental.theories.FromDataPoints;
  21 import org.junit.experimental.theories.Theories;
  22 import org.junit.experimental.theories.Theory;
  23 import org.junit.runner.RunWith;
  24 import org.mockito.BDDMockito;
  25 import org.mockito.Mockito;
  26
  27 import de.xn__ho_hia.quality.suppression.CompilerWarnings;
  28 import de.xn__ho_hia.storage_unit.CommonKilobyte;
  29 import de.xn__ho_hia.storage_unit.Kibibyte;
  30 import de.xn__ho_hia.storage_unit.Kilobyte;
  31 import de.xn__ho_hia.storage_unit.StorageUnit;
  32 import de.xn__ho_hia.storage_unit.StorageUnits;
  33
  34 /**
  35  *
  36  */
  37 @RunWith(Theories.class)
  38 @SuppressWarnings(CompilerWarnings.STATIC_METHOD)
  39 public class StorageUnitCodecTest {
  40
  41     /**
  42      * @return Suppliers to create a storage-unit codec.
  43      */
  44     @DataPoints("supplier")
  45     public static final List<Tuple2<Supplier<AbstractStorageUnitCodec>, Class<?>>> suppliers() {
  46         final List<Tuple2<Supplier<AbstractStorageUnitCodec>, Class<?>>> suppliers = new ArrayList<>();
  47         suppliers.add(new Tuple2<>(BinaryStorageUnitCodec::new, Kibibyte.class));
  48         suppliers.add(new Tuple2<>(CommonStorageUnitCodec::new, CommonKilobyte.class));
  49         suppliers.add(new Tuple2<>(DecimalStorageUnitCodec::new, Kilobyte.class));
  50         return suppliers;
  51     }
  52
  53     /**
  54      * @param supplier
  55      *            The supplier to use.
  56      */
  57     @Theory
  58     public void shouldEncodeStorageUnitClass(
  59             @FromDataPoints("supplier") final Tuple2<Supplier<AbstractStorageUnitCodec>, Class<?>> supplier) {
  60         // given
  61         final AbstractStorageUnitCodec codec = supplier.v1.get();
  62
  63         // when
  64         final Class<StorageUnit<?>> encoderClass = codec.getEncoderClass();
  65
  66         // then
  67         Assert.assertNotNull(encoderClass);
  68         Assert.assertEquals(StorageUnit.class, encoderClass);
  69     }
  70
  71     /**
  72      * @param supplier
  73      *            The supplier to use.
  74      */
  75     @Theory
  76     @SuppressWarnings(CompilerWarnings.NLS)
  77     public void shouldEncodeStorageUnit(
  78             @FromDataPoints("supplier") final Tuple2<Supplier<AbstractStorageUnitCodec>, Class<?>> supplier) {
  79         // given
  80         final AbstractStorageUnitCodec codec = supplier.v1.get();
  81         final BsonWriter writer = Mockito.mock(BsonWriter.class);
  82         final EncoderContext context = EncoderContext.builder().build();
  83         final StorageUnit<?> value = StorageUnits.kilobyte(1L);
  84
  85         // when
  86         codec.encode(writer, value, context);
  87
  88         // then
  89         Mockito.verify(writer).writeString("1000");
  90     }
  91
  92     /**
  93      * @param supplier
  94      *            The supplier to use.
  95      */
  96     @Theory
  97     @SuppressWarnings(CompilerWarnings.NLS)
  98     public void shouldDecodeStorageUnit(
  99             @FromDataPoints("supplier") final Tuple2<Supplier<AbstractStorageUnitCodec>, Class<?>> supplier) {
 100         // given
 101         final AbstractStorageUnitCodec codec = supplier.v1.get();
 102         final BsonReader reader = Mockito.mock(BsonReader.class);
 103         final DecoderContext context = DecoderContext.builder().build();
 104         BDDMockito.given(reader.readString()).willReturn("2000");
 105
 106         // when
 107         final StorageUnit<?> value = codec.decode(reader, context);
 108
 109         // then
 110         Assert.assertNotNull(value);
 111         Assert.assertEquals(supplier.v2, value.getClass());
 112     }
 113
 114 }