#1259 - Throw explicit mapping error when an Enum is mapped to both ORDINAL and STRING

src/test/java/io/ebean/server/type/TestTypeManager.java

@@ -12,10 +12,12 @@ import org.junit.Test;
 import org.tests.model.ivo.Money;
 import org.tests.model.ivo.converter.MoneyTypeConverter;
 
+import javax.persistence.EnumType;
 import java.sql.SQLException;
 import java.sql.Types;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertTrue;
 
 public class TestTypeManager extends BaseTestCase {
 
@@ -42,6 +44,13 @@ public class TestTypeManager extends BaseTestCase {
     assertThat(typeA).isNotNull();
     ScalarType<?> typeC = typeManager.getScalarType(MyEnum.Cval.getClass());
     assertThat(typeC).isNotNull();
+
+    try {
+      typeManager.createEnumScalarType(MyEnum.class, EnumType.STRING);
+      assertTrue("never get here",false);
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
+    }
   }
 
   @Test
@@ -65,6 +74,13 @@ public class TestTypeManager extends BaseTestCase {
 
     val = dayOfWeekType.read(new DummyDataReader("FRIDAY   "));
     assertThat(val).isEqualTo(MyDayOfWeek.FRIDAY);
+
+    try {
+      typeManager.createEnumScalarType(MyDayOfWeek.class, EnumType.ORDINAL);
+      assertTrue("never get here",false);
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
+    }
   }
 
   @Test
@@ -73,8 +89,8 @@ public class TestTypeManager extends BaseTestCase {
     DefaultTypeManager typeManager = createTypeManager();
 
     ScalarType<?> scalarType = typeManager.getScalarType(Money.class);
-    Assert.assertTrue(scalarType.getJdbcType() == Types.DECIMAL);
-    Assert.assertTrue(!scalarType.isJdbcNative());
+    assertTrue(scalarType.getJdbcType() == Types.DECIMAL);
+    assertTrue(!scalarType.isJdbcNative());
     Assert.assertEquals(Money.class, scalarType.getType());
 
   }

src/test/java/io/ebeaninternal/server/type/DefaultTypeManagerTest.java

@@ -5,23 +5,28 @@ import io.ebean.config.dbplatform.postgres.PostgresPlatform;
 import io.ebeaninternal.server.core.bootup.BootupClasses;
 import org.junit.Test;
 
+import javax.persistence.EnumType;
+import java.time.DayOfWeek;
+import java.time.Month;
+
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 public class DefaultTypeManagerTest {
 
-  DefaultTypeManager typeManager;
-
-  public DefaultTypeManagerTest() {
+  private DefaultTypeManager create() {
     ServerConfig serverConfig = new ServerConfig();
     serverConfig.setDatabasePlatform(new PostgresPlatform());
     BootupClasses bootupClasses = new BootupClasses();
-    typeManager = new DefaultTypeManager(serverConfig, bootupClasses);
+    return new DefaultTypeManager(serverConfig, bootupClasses);
   }
 
   @Test
   public void isIntegerType() {
 
+    DefaultTypeManager typeManager = create();
+
     assertTrue(typeManager.isIntegerType("1"));
     assertTrue(typeManager.isIntegerType("0"));
 
@@ -33,4 +38,82 @@ public class DefaultTypeManagerTest {
     assertFalse(typeManager.isIntegerType(" A"));
   }
 
+
+  @Test
+  public void enumDayMonth_builtIn_overrideAsString() {
+
+    DefaultTypeManager typeManager = create();
+
+    ScalarType<?> type = typeManager.createEnumScalarType(Month.class, null);
+    assertThat(type).isInstanceOf(ScalarTypeEnumWithMapping.class).as("built in type");
+
+    // mapped explicitly as JPA EnumType.STRING
+    type = typeManager.createEnumScalarType(Month.class, EnumType.STRING);
+    assertThat(type).isInstanceOf(ScalarTypeEnumStandard.StringEnum.class).as("override built in type");
+
+    try {
+      typeManager.createEnumScalarType(Month.class, EnumType.ORDINAL);
+      assertThat(true).isFalse().as("never get here");
+
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
+    }
+  }
+
+  @Test
+  public void enumMonth_builtIn_overrideAsOrdinal() {
+
+    DefaultTypeManager typeManager = create();
+
+    // mapped explicitly as JPA EnumType.STRING
+    ScalarType<?> type = typeManager.createEnumScalarType(Month.class, EnumType.ORDINAL);
+    assertThat(type).isInstanceOf(ScalarTypeEnumStandard.OrdinalEnum.class).as("override built in type");
+
+    try {
+      typeManager.createEnumScalarType(Month.class, EnumType.STRING);
+      assertThat(true).isFalse().as("never get here");
+
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
+    }
+  }
+
+  @Test
+  public void enumDayOfWeek_builtIn_overrideAsString() {
+
+    DefaultTypeManager typeManager = create();
+
+    ScalarType<?> type = typeManager.createEnumScalarType(DayOfWeek.class, null);
+    assertThat(type).isInstanceOf(ScalarTypeEnumWithMapping.class).as("built in type");
+
+    // mapped explicitly as JPA EnumType.STRING
+    type = typeManager.createEnumScalarType(DayOfWeek.class, EnumType.STRING);
+    assertThat(type).isInstanceOf(ScalarTypeEnumStandard.StringEnum.class).as("override built in type");
+
+    try {
+      typeManager.createEnumScalarType(DayOfWeek.class, EnumType.ORDINAL);
+      assertThat(true).isFalse().as("never get here");
+
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
+    }
+  }
+
+  @Test
+  public void enumDayOfWeek_builtIn_overrideAsOrdinal() {
+
+    DefaultTypeManager typeManager = create();
+
+    // mapped explicitly as JPA EnumType.STRING
+    ScalarType<?> type = typeManager.createEnumScalarType(DayOfWeek.class, EnumType.ORDINAL);
+    assertThat(type).isInstanceOf(ScalarTypeEnumStandard.OrdinalEnum.class).as("override built in type");
+
+    try {
+      typeManager.createEnumScalarType(DayOfWeek.class, EnumType.STRING);
+      assertThat(true).isFalse().as("never get here");
+
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
+    }
+  }
 }