Add JPA annotations to class Registrar (#430)

* Add JPA annotations to class Registrar

* Use array for Java list

* Exclude parent field

* Use 3 columns for address and use text for enum

* Use EnumParameter and 3 properties in Address

* Rename columns and rebase on HEAD

core/src/test/java/google/registry/persistence/CidrAddressBlockListUserTypeTest.java

@@ -0,0 +1,71 @@
+// Copyright 2020 The Nomulus Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.persistence;
+
+import static com.google.common.truth.Truth.assertThat;
+import static google.registry.persistence.transaction.TransactionManagerFactory.jpaTm;
+
+import com.google.common.collect.ImmutableList;
+import google.registry.model.ImmutableObject;
+import google.registry.persistence.transaction.JpaTestRules;
+import google.registry.persistence.transaction.JpaTestRules.JpaUnitTestRule;
+import google.registry.util.CidrAddressBlock;
+import java.util.List;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import org.hibernate.annotations.Type;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CidrAddressBlockListUserType}. */
+@RunWith(JUnit4.class)
+public class CidrAddressBlockListUserTypeTest {
+  @Rule
+  public final JpaUnitTestRule jpaRule =
+      new JpaTestRules.Builder().withEntityClass(TestEntity.class).buildUnitTestRule();
+
+  @Test
+  public void roundTripConversion_returnsSameCidrAddressBlock() {
+    List<CidrAddressBlock> addresses =
+        ImmutableList.of(
+            CidrAddressBlock.create("0.0.0.0/32"),
+            CidrAddressBlock.create("255.255.255.254/31"),
+            CidrAddressBlock.create("::"),
+            CidrAddressBlock.create("8000::/1"),
+            CidrAddressBlock.create("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"));
+    TestEntity testEntity = new TestEntity(addresses);
+    jpaTm().transact(() -> jpaTm().getEntityManager().persist(testEntity));
+    TestEntity persisted =
+        jpaTm().transact(() -> jpaTm().getEntityManager().find(TestEntity.class, "id"));
+    assertThat(persisted.addresses).isEqualTo(addresses);
+  }
+
+  @Entity(name = "TestEntity") // Override entity name to avoid the nested class reference.
+  private static class TestEntity extends ImmutableObject {
+
+    @Id String name = "id";
+
+    @Type(type = "google.registry.persistence.CidrAddressBlockListUserType")
+    List<CidrAddressBlock> addresses;
+
+    private TestEntity() {}
+
+    private TestEntity(List<CidrAddressBlock> addresses) {
+      this.addresses = addresses;
+    }
+  }
+}

core/src/test/java/google/registry/persistence/CurrencyToBillingMapUserTypeTest.java

@@ -0,0 +1,74 @@
+// Copyright 2020 The Nomulus Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.persistence;
+
+import static com.google.common.truth.Truth.assertThat;
+import static google.registry.persistence.transaction.TransactionManagerFactory.jpaTm;
+
+import com.google.common.collect.ImmutableMap;
+import google.registry.model.ImmutableObject;
+import google.registry.model.registrar.Registrar.BillingAccountEntry;
+import google.registry.persistence.transaction.JpaTestRules;
+import google.registry.persistence.transaction.JpaTestRules.JpaUnitTestRule;
+import java.util.Map;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import org.hibernate.annotations.Type;
+import org.joda.money.CurrencyUnit;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CurrencyToBillingMapUserType}. */
+@RunWith(JUnit4.class)
+public class CurrencyToBillingMapUserTypeTest {
+  @Rule
+  public final JpaUnitTestRule jpaRule =
+      new JpaTestRules.Builder()
+          .withInitScript("sql/flyway/V14__load_extension_for_hstore.sql")
+          .withEntityClass(TestEntity.class)
+          .buildUnitTestRule();
+
+  @Test
+  public void roundTripConversion_returnsSameCurrencyToBillingMap() {
+    ImmutableMap<CurrencyUnit, BillingAccountEntry> currencyToBilling =
+        ImmutableMap.of(
+            CurrencyUnit.of("USD"),
+            new BillingAccountEntry(CurrencyUnit.of("USD"), "accountId1"),
+            CurrencyUnit.of("CNY"),
+            new BillingAccountEntry(CurrencyUnit.of("CNY"), "accountId2"));
+    TestEntity testEntity = new TestEntity(currencyToBilling);
+    jpaTm().transact(() -> jpaTm().getEntityManager().persist(testEntity));
+    TestEntity persisted =
+        jpaTm().transact(() -> jpaTm().getEntityManager().find(TestEntity.class, "id"));
+    assertThat(persisted.currencyToBilling).containsExactlyEntriesIn(currencyToBilling);
+  }
+
+  @Entity(name = "TestEntity") // Override entity name to avoid the nested class reference.
+  private static class TestEntity extends ImmutableObject {
+
+    @Id String name = "id";
+
+    @Type(type = "google.registry.persistence.CurrencyToBillingMapUserType")
+    Map<CurrencyUnit, BillingAccountEntry> currencyToBilling;
+
+    private TestEntity() {}
+
+    private TestEntity(Map<CurrencyUnit, BillingAccountEntry> currencyToBilling) {
+      this.currencyToBilling = currencyToBilling;
+    }
+  }
+}

core/src/test/java/google/registry/persistence/EnumSetUserTypeTest.java

@@ -56,8 +56,8 @@ public class EnumSetUserTypeTest {
 
     public static class TestEnumType extends EnumSetUserType<TestEnum> {
       @Override
-      protected Object convertToElem(Object value) {
-        return TestEnum.valueOf((String) value);
+      protected TestEnum convertToElem(String value) {
+        return TestEnum.valueOf(value);
       }
     }
   }

core/src/test/java/google/registry/persistence/RegistrarStateConverterTest.java

@@ -0,0 +1,77 @@
+// Copyright 2020 The Nomulus Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.persistence;
+
+import static com.google.common.truth.Truth.assertThat;
+import static google.registry.persistence.transaction.TransactionManagerFactory.jpaTm;
+
+import google.registry.model.ImmutableObject;
+import google.registry.model.registrar.Registrar.State;
+import google.registry.persistence.transaction.JpaTestRules;
+import google.registry.persistence.transaction.JpaTestRules.JpaUnitTestRule;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link RegistrarStateConverter}. */
+@RunWith(JUnit4.class)
+public class RegistrarStateConverterTest {
+
+  @Rule
+  public final JpaUnitTestRule jpaRule =
+      new JpaTestRules.Builder().withEntityClass(TestEntity.class).buildUnitTestRule();
+
+  @Test
+  public void roundTripConversion_returnsSameEnum() {
+    TestEntity testEntity = new TestEntity(State.ACTIVE);
+    jpaTm().transact(() -> jpaTm().getEntityManager().persist(testEntity));
+    TestEntity persisted =
+        jpaTm().transact(() -> jpaTm().getEntityManager().find(TestEntity.class, "id"));
+    assertThat(persisted.state).isEqualTo(State.ACTIVE);
+  }
+
+  @Test
+  public void testNativeQuery_succeeds() {
+    TestEntity testEntity = new TestEntity(State.DISABLED);
+    jpaTm().transact(() -> jpaTm().getEntityManager().persist(testEntity));
+
+    assertThat(
+            jpaTm()
+                .transact(
+                    () ->
+                        jpaTm()
+                            .getEntityManager()
+                            .createNativeQuery("SELECT state FROM \"TestEntity\" WHERE name = 'id'")
+                            .getSingleResult()))
+        .isEqualTo("DISABLED");
+  }
+
+  @Entity(name = "TestEntity") // Override entity name to avoid the nested class reference.
+  private static class TestEntity extends ImmutableObject {
+
+    @Id String name = "id";
+
+    State state;
+
+    private TestEntity() {}
+
+    private TestEntity(State state) {
+      this.state = state;
+    }
+  }
+}

core/src/test/java/google/registry/persistence/RegistrarTypeConverterTest.java

@@ -0,0 +1,76 @@
+// Copyright 2020 The Nomulus Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.persistence;
+
+import static com.google.common.truth.Truth.assertThat;
+import static google.registry.persistence.transaction.TransactionManagerFactory.jpaTm;
+
+import google.registry.model.ImmutableObject;
+import google.registry.model.registrar.Registrar.Type;
+import google.registry.persistence.transaction.JpaTestRules;
+import google.registry.persistence.transaction.JpaTestRules.JpaUnitTestRule;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link RegistrarTypeConverter}. */
+@RunWith(JUnit4.class)
+public class RegistrarTypeConverterTest {
+  @Rule
+  public final JpaUnitTestRule jpaRule =
+      new JpaTestRules.Builder().withEntityClass(TestEntity.class).buildUnitTestRule();
+
+  @Test
+  public void roundTripConversion_returnsSameEnum() {
+    TestEntity testEntity = new TestEntity(Type.MONITORING);
+    jpaTm().transact(() -> jpaTm().getEntityManager().persist(testEntity));
+    TestEntity persisted =
+        jpaTm().transact(() -> jpaTm().getEntityManager().find(TestEntity.class, "id"));
+    assertThat(persisted.type).isEqualTo(Type.MONITORING);
+  }
+
+  @Test
+  public void testNativeQuery_succeeds() {
+    TestEntity testEntity = new TestEntity(Type.MONITORING);
+    jpaTm().transact(() -> jpaTm().getEntityManager().persist(testEntity));
+
+    assertThat(
+            jpaTm()
+                .transact(
+                    () ->
+                        jpaTm()
+                            .getEntityManager()
+                            .createNativeQuery("SELECT type FROM \"TestEntity\" WHERE name = 'id'")
+                            .getSingleResult()))
+        .isEqualTo("MONITORING");
+  }
+
+  @Entity(name = "TestEntity") // Override entity name to avoid the nested class reference.
+  private static class TestEntity extends ImmutableObject {
+
+    @Id String name = "id";
+
+    Type type;
+
+    private TestEntity() {}
+
+    private TestEntity(Type type) {
+      this.type = type;
+    }
+  }
+}