Merge pull request #200 from sibyg/sibyg

Add local date converter, expose register() on enveloper, add random generators

Author: purple52

common/src/main/java/uk/gov/justice/services/common/converter/LocalDates.java

@@ -0,0 +1,39 @@
+package uk.gov.justice.services.common.converter;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * Utility functions for converting to and from {@link LocalDate} objects
+ * and ISO date format String such as '2011-12-03'
+ */
+public final class LocalDates {
+
+    private static DateTimeFormatter FORMAT = DateTimeFormatter.ISO_DATE;
+
+    /**
+     * Private constructor to avoid misuse of utility class.
+     */
+    private LocalDates() {
+    }
+
+    /**
+     * Parses a string in ISO date format such as '2011-12-03' to create a {@link LocalDate} object
+     *
+     * @param source the @link LocalDate}  as a string in ISO_DATE format
+     * @return LocalDate object
+     */
+    public static LocalDate from(final String source) {
+        return LocalDate.parse(source, FORMAT);
+    }
+
+    /**
+     * Format a {@link LocalDate} object to ISO date format string such as '2011-12-03'
+     *
+     * @param source the date time
+     * @return the date time as a string
+     */
+    public static String to(final LocalDate source) {
+        return source.format(FORMAT);
+    }
+}

common/src/test/java/uk/gov/justice/services/common/converter/LocalDatesTest.java

@@ -0,0 +1,118 @@
+package uk.gov.justice.services.common.converter;
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.junit.Test;
+
+import java.time.LocalDate;
+
+import static java.lang.String.format;
+import static net.trajano.commons.testing.UtilityClassTestUtil.assertUtilityClassWellDefined;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * Unit tests for the {@link LocalDates} utility class.
+ */
+public class LocalDatesTest {
+
+    @Test
+    public void shouldBeWellDefinedUtilityClass() {
+        assertUtilityClassWellDefined(LocalDates.class);
+    }
+
+    @Test
+    public void shouldConvertStringToLocalDate() {
+        // given
+        int year = 2016;
+        // and
+        int month = 11;
+        // and
+        int dayOfMonth = 21;
+        // and
+        String localDateStr = format("%d-%02d-%d", year, month, dayOfMonth);
+
+        // when
+        final LocalDate localDate = LocalDates.from(localDateStr);
+
+        // then
+        assertThat(localDate, has(year, month, dayOfMonth));
+
+    }
+
+    private Matcher<LocalDate> has(final int year, final int month, final int dayOfMonth) {
+        return new TypeSafeDiagnosingMatcher<LocalDate>() {
+
+            @Override
+            public void describeTo(Description description) {
+                description.appendText("from() should return ").appendValue(format("%d-%d-%d", year, month, dayOfMonth));
+            }
+
+            @Override
+            protected boolean matchesSafely(LocalDate localDate, Description description) {
+                boolean status = true;
+                if (localDate.getYear() != year) {
+                    description.appendText(format("Year Mismatch, Actual:%d, Expected:%s", localDate.getYear(), year));
+                    status = false;
+                }
+                if (localDate.getMonth().getValue() != month) {
+                    description.appendText(format(" Month Mismatch, Actual:%d, Expected:%s", localDate.getMonth().getValue(), month));
+                    status = false;
+                }
+                if (localDate.getDayOfMonth() != dayOfMonth) {
+                    description.appendText(format(" Day Of Month Mismatch, Actual:%d, Expected:%s", localDate.getDayOfMonth(), dayOfMonth));
+                    status = false;
+                }
+                return status;
+            }
+        };
+    }
+
+    @Test
+    public void shouldConvertLocalDateToString() {
+        // given
+        LocalDate localDate = LocalDate.now();
+
+        // when
+        String str = LocalDates.to(localDate);
+
+        // then
+        assertThat(str, isFrom(localDate));
+    }
+
+    private Matcher<String> isFrom(final LocalDate localDate) {
+        return new TypeSafeDiagnosingMatcher<String>() {
+
+            @Override
+            public void describeTo(Description description) {
+                description.appendText("to() should return LocalDate:").appendValue(localDate);
+            }
+
+            @Override
+            protected boolean matchesSafely(String str, Description description) {
+                boolean status = true;
+                String[] tokens = str.split("-");
+
+                if (tokens.length != 3) {
+                    description.appendText("Unformatted string");
+                    return false;
+                }
+
+
+                if (Integer.valueOf(tokens[0]) != localDate.getYear()) {
+                    description.appendText(format("Year Mismatch, Actual:%s, Expected:%d", tokens[0], localDate.getYear()));
+                    status = false;
+                }
+                if (Integer.valueOf(tokens[1]) != localDate.getMonth().getValue()) {
+                    description.appendText(format(" Month Mismatch, Actual:%s, Expected:%02d", tokens[1], localDate.getMonth().getValue()));
+                    status = false;
+                }
+                if (Integer.valueOf(tokens[2]) != localDate.getDayOfMonth()) {
+                    description.appendText(format(" Day Of Month Mismatch, Actual:%s, Expected:%d", tokens[2], localDate.getDayOfMonth()));
+                    status = false;
+                }
+                return status;
+            }
+        };
+    }
+}

core/src/main/java/uk/gov/justice/services/core/enveloper/Enveloper.java

@@ -56,7 +56,7 @@ public Enveloper(final ObjectToJsonValueConverter objectToJsonValueConverter) {
      *
      * @param event identified by the framework to be registered into the event map.
      */
-    void register(@Observes final EventFoundEvent event) {
+    public void register(@Observes final EventFoundEvent event) {
         eventMap.putIfAbsent(event.getClazz(), event.getEventName());
     }
 

test-utils/test-utils-core/src/main/java/uk/gov/justice/services/test/utils/core/random/BigDecimalGenerator.java

@@ -0,0 +1,23 @@
+package uk.gov.justice.services.test.utils.core.random;
+
+import java.math.BigDecimal;
+
+import static java.lang.Math.pow;
+import static java.math.RoundingMode.FLOOR;
+
+public class BigDecimalGenerator extends Generator<BigDecimal> {
+
+    private final Integer max;
+    private final Integer decimalPlaces;
+
+    public BigDecimalGenerator(final Integer max, final Integer decimalPlaces) {
+        this.max = max;
+        this.decimalPlaces = decimalPlaces;
+    }
+
+    @Override
+    public BigDecimal next() {
+        final double pow = pow(10, decimalPlaces);
+        return new BigDecimal((long) RANDOM.nextInt((int) (max * pow)) / pow).setScale(decimalPlaces, FLOOR);
+    }
+}

test-utils/test-utils-core/src/main/java/uk/gov/justice/services/test/utils/core/random/BooleanGenerator.java

@@ -0,0 +1,8 @@
+package uk.gov.justice.services.test.utils.core.random;
+
+public class BooleanGenerator extends Generator<Boolean> {
+    @Override
+    public Boolean next() {
+        return RANDOM.nextBoolean();
+    }
+}

test-utils/test-utils-core/src/main/java/uk/gov/justice/services/test/utils/core/random/DoubleGenerator.java

@@ -0,0 +1,20 @@
+package uk.gov.justice.services.test.utils.core.random;
+
+import static java.lang.Math.pow;
+
+class DoubleGenerator extends Generator<Double> {
+
+    private final Integer max;
+    private final Integer decimalPlaces;
+
+    public DoubleGenerator(final Integer max, final Integer decimalPlaces) {
+        this.max = max;
+        this.decimalPlaces = decimalPlaces;
+    }
+
+    @Override
+    public Double next() {
+        final double pow = pow(10, decimalPlaces);
+        return (double) RANDOM.nextInt((int) (max * pow)) / pow;
+    }
+}

test-utils/test-utils-core/src/main/java/uk/gov/justice/services/test/utils/core/random/EmailAddressGenerator.java

@@ -0,0 +1,10 @@
+package uk.gov.justice.services.test.utils.core.random;
+
+import static java.lang.String.format;
+
+public class EmailAddressGenerator extends Generator<String> {
+    @Override
+    public String next() {
+        return format("%s@%s.%s", RandomGenerator.string(10).next(), RandomGenerator.string(10).next(), RandomGenerator.values("com", "co.uk", "gov.uk", "org", "net").next());
+    }
+}

test-utils/test-utils-core/src/main/java/uk/gov/justice/services/test/utils/core/random/Generator.java

@@ -0,0 +1,13 @@
+package uk.gov.justice.services.test.utils.core.random;
+
+import java.util.Random;
+
+/**
+ * Provides template for random value generation
+ * for a given type T
+ * @param <T> random value of T will be generated by the implementing class
+ */
+public abstract class Generator<T> {
+    final Random RANDOM = new java.util.Random();
+    abstract T next();
+}

test-utils/test-utils-core/src/main/java/uk/gov/justice/services/test/utils/core/random/IntegerGenerator.java

@@ -0,0 +1,15 @@
+package uk.gov.justice.services.test.utils.core.random;
+
+public class IntegerGenerator extends Generator<Integer> {
+
+    private final Integer max;
+
+    public IntegerGenerator(final Integer max) {
+        this.max = max;
+    }
+
+    @Override
+    public Integer next() {
+        return RANDOM.nextInt(max);
+    }
+}

test-utils/test-utils-core/src/main/java/uk/gov/justice/services/test/utils/core/random/LocalDateGenerator.java

@@ -0,0 +1,42 @@
+package uk.gov.justice.services.test.utils.core.random;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import static java.time.Instant.ofEpochMilli;
+import static java.time.ZoneOffset.UTC;
+import static uk.gov.justice.services.test.utils.core.random.LocalDateGenerator.Direction.FORWARD;
+
+public class LocalDateGenerator extends Generator<LocalDate> {
+    private final LocalDate start;
+    private final LocalDate end;
+    private final Direction direction;
+
+    public LocalDateGenerator(final Period period, final LocalDate start, final Direction direction) {
+        this.start = start;
+        this.direction = direction;
+        this.end = direction == FORWARD ? start.plus(period) : start.minus(period);
+    }
+
+    @Override
+    public LocalDate next() {
+        final ZonedDateTime startZDT = start.atStartOfDay(UTC);
+        final ZonedDateTime endZDT = end.atStartOfDay(UTC);
+        final long startMillsecs = startZDT.toInstant().toEpochMilli();
+        final long endMillisecs = endZDT.toInstant().toEpochMilli();
+
+        Long randomMillsecs;
+
+        if (direction == FORWARD) {
+            randomMillsecs = RANDOM.longs(startMillsecs, endMillisecs).findFirst().getAsLong();
+        } else {
+            randomMillsecs = RANDOM.longs(endMillisecs, startMillsecs).findFirst().getAsLong();
+        }
+
+        return ofEpochMilli(randomMillsecs).atZone(ZoneId.systemDefault()).toLocalDate();
+    }
+
+    public static enum Direction {FORWARD, BACKWARD}
+}