From 933394e8c3a414c7cbbdcdc2fde7b8f193f0ae14 Mon Sep 17 00:00:00 2001 From: Michael Muller Date: Mon, 21 Sep 2020 09:10:01 -0400 Subject: [PATCH] Improve naming of TransactionManager methods (#802) * Improve naming of TransactionManager methods Per internal discussion, convert names of methods as follows: saveNew -> insert saveNewOrUpdate -> put checkExists -> exists Likewise, convert derived names to their corresponding forms, e.g. saveNewOrUpdateAll -> putAll. --- .../batch/DeleteContactsAndHostsAction.java | 2 +- .../registry/beam/initsql/Transforms.java | 2 +- .../registry/beam/spec11/Spec11Pipeline.java | 2 +- .../domain/DomainRestoreRequestFlow.java | 2 +- .../registry/flows/host/HostUpdateFlow.java | 6 +- .../registry/flows/poll/PollFlowUtils.java | 2 +- .../ofy/DatastoreTransactionManager.java | 12 +- .../label/ReservedListDualWriteDao.java | 2 +- .../registry/label/ReservedListSqlDao.java | 2 +- .../JpaTransactionManagerImpl.java | 24 ++-- .../persistence/transaction/Transaction.java | 2 +- .../transaction/TransactionManager.java | 12 +- .../tools/CreateRegistrarCommand.java | 2 +- .../registry/beam/initsql/WriteToSqlTest.java | 2 +- .../beam/spec11/Spec11PipelineTest.java | 2 +- .../model/billing/BillingEventTest.java | 2 +- .../model/contact/ContactResourceTest.java | 4 +- .../model/domain/DomainBaseSqlTest.java | 42 +++--- .../domain/token/AllocationTokenTest.java | 4 +- .../model/history/ContactHistoryTest.java | 8 +- .../model/history/DomainHistoryTest.java | 16 +-- .../model/history/HostHistoryTest.java | 8 +- .../registry/model/poll/PollMessageTest.java | 8 +- .../registry/model/registry/RegistryTest.java | 2 +- .../reporting/Spec11ThreatMatchDaoTest.java | 4 +- .../reporting/Spec11ThreatMatchTest.java | 22 ++-- .../EntityCallbacksListenerTest.java | 2 +- .../converter/DurationConverterTest.java | 2 +- .../InetAddressSetConverterTest.java | 2 +- .../converter/LocalDateConverterTest.java | 2 +- .../JpaTransactionManagerImplTest.java | 124 +++++++++--------- .../transaction/TransactionManagerTest.java | 44 +++---- .../transaction/TransactionTest.java | 19 ++- .../registry/rde/RdeStagingMapperTest.java | 2 +- .../registrar/RegistrarContactTest.java | 2 +- .../schema/registrar/RegistrarDaoTest.java | 14 +- .../google/registry/testing/SqlHelper.java | 2 +- .../tools/CreateRegistrarCommandTest.java | 2 +- .../tools/UpdateRegistrarCommandTest.java | 2 +- 39 files changed, 206 insertions(+), 209 deletions(-) diff --git a/core/src/main/java/google/registry/batch/DeleteContactsAndHostsAction.java b/core/src/main/java/google/registry/batch/DeleteContactsAndHostsAction.java index 5d58017c7..c09f24945 100644 --- a/core/src/main/java/google/registry/batch/DeleteContactsAndHostsAction.java +++ b/core/src/main/java/google/registry/batch/DeleteContactsAndHostsAction.java @@ -464,7 +464,7 @@ public class DeleteContactsAndHostsAction implements Runnable { HostResource host = (HostResource) existingResource; if (host.isSubordinate()) { dnsQueue.addHostRefreshTask(host.getHostName()); - tm().saveNewOrUpdate( + tm().put( tm().load(host.getSuperordinateDomain()) .asBuilder() .removeSubordinateHost(host.getHostName()) diff --git a/core/src/main/java/google/registry/beam/initsql/Transforms.java b/core/src/main/java/google/registry/beam/initsql/Transforms.java index 3011cc4d4..78e61cf55 100644 --- a/core/src/main/java/google/registry/beam/initsql/Transforms.java +++ b/core/src/main/java/google/registry/beam/initsql/Transforms.java @@ -437,7 +437,7 @@ public final class Transforms { .map(Optional::get) .map(ofy::toPojo) .collect(ImmutableList.toImmutableList()); - retry(() -> jpaTm().transact(() -> jpaTm().saveNewOrUpdateAll(ofyEntities))); + retry(() -> jpaTm().transact(() -> jpaTm().putAll(ofyEntities))); } } diff --git a/core/src/main/java/google/registry/beam/spec11/Spec11Pipeline.java b/core/src/main/java/google/registry/beam/spec11/Spec11Pipeline.java index 5ed84b1dc..7f06d82e8 100644 --- a/core/src/main/java/google/registry/beam/spec11/Spec11Pipeline.java +++ b/core/src/main/java/google/registry/beam/spec11/Spec11Pipeline.java @@ -215,7 +215,7 @@ public class Spec11Pipeline implements Serializable { .setRegistrarId(subdomain.registrarId()) .build(); JpaTransactionManager jpaTransactionManager = jpaSupplierFactory.get(); - jpaTransactionManager.transact(() -> jpaTransactionManager.saveNew(threatMatch)); + jpaTransactionManager.transact(() -> jpaTransactionManager.insert(threatMatch)); } } })); diff --git a/core/src/main/java/google/registry/flows/domain/DomainRestoreRequestFlow.java b/core/src/main/java/google/registry/flows/domain/DomainRestoreRequestFlow.java index f7899a372..f1ed7934d 100644 --- a/core/src/main/java/google/registry/flows/domain/DomainRestoreRequestFlow.java +++ b/core/src/main/java/google/registry/flows/domain/DomainRestoreRequestFlow.java @@ -173,7 +173,7 @@ public final class DomainRestoreRequestFlow implements TransactionalFlow { existingDomain, newExpirationTime, autorenewEvent, autorenewPollMessage, now, clientId); updateForeignKeyIndexDeletionTime(newDomain); entitiesToSave.add(newDomain, historyEntry, autorenewEvent, autorenewPollMessage); - tm().saveNewOrUpdateAll(entitiesToSave.build()); + tm().putAll(entitiesToSave.build()); tm().delete(existingDomain.getDeletePollMessage()); dnsQueue.addDomainRefreshTask(existingDomain.getDomainName()); return responseBuilder diff --git a/core/src/main/java/google/registry/flows/host/HostUpdateFlow.java b/core/src/main/java/google/registry/flows/host/HostUpdateFlow.java index a09935f91..07bd29450 100644 --- a/core/src/main/java/google/registry/flows/host/HostUpdateFlow.java +++ b/core/src/main/java/google/registry/flows/host/HostUpdateFlow.java @@ -285,7 +285,7 @@ public final class HostUpdateFlow implements TransactionalFlow { && newHost.isSubordinate() && Objects.equals( existingHost.getSuperordinateDomain(), newHost.getSuperordinateDomain())) { - tm().saveNewOrUpdate( + tm().put( tm().load(existingHost.getSuperordinateDomain()) .asBuilder() .removeSubordinateHost(existingHost.getHostName()) @@ -294,14 +294,14 @@ public final class HostUpdateFlow implements TransactionalFlow { return; } if (existingHost.isSubordinate()) { - tm().saveNewOrUpdate( + tm().put( tm().load(existingHost.getSuperordinateDomain()) .asBuilder() .removeSubordinateHost(existingHost.getHostName()) .build()); } if (newHost.isSubordinate()) { - tm().saveNewOrUpdate( + tm().put( tm().load(newHost.getSuperordinateDomain()) .asBuilder() .addSubordinateHost(newHost.getHostName()) diff --git a/core/src/main/java/google/registry/flows/poll/PollFlowUtils.java b/core/src/main/java/google/registry/flows/poll/PollFlowUtils.java index 1e6db7ba5..6befedeb7 100644 --- a/core/src/main/java/google/registry/flows/poll/PollFlowUtils.java +++ b/core/src/main/java/google/registry/flows/poll/PollFlowUtils.java @@ -64,7 +64,7 @@ public final class PollFlowUtils { // and re-save it for future autorenew poll messages to be delivered. Otherwise, this // autorenew poll message has no more events to deliver and should be deleted. if (nextEventTime.isBefore(autorenewPollMessage.getAutorenewEndTime())) { - tm().saveNewOrUpdate(autorenewPollMessage.asBuilder().setEventTime(nextEventTime).build()); + tm().put(autorenewPollMessage.asBuilder().setEventTime(nextEventTime).build()); includeAckedMessageInCount = isBeforeOrAt(nextEventTime, tm().getTransactionTime()); } else { tm().delete(autorenewPollMessage.createVKey()); diff --git a/core/src/main/java/google/registry/model/ofy/DatastoreTransactionManager.java b/core/src/main/java/google/registry/model/ofy/DatastoreTransactionManager.java index a6a4baa47..8dc474293 100644 --- a/core/src/main/java/google/registry/model/ofy/DatastoreTransactionManager.java +++ b/core/src/main/java/google/registry/model/ofy/DatastoreTransactionManager.java @@ -101,22 +101,22 @@ public class DatastoreTransactionManager implements TransactionManager { } @Override - public void saveNew(Object entity) { + public void insert(Object entity) { saveEntity(entity); } @Override - public void saveAllNew(ImmutableCollection entities) { + public void insertAll(ImmutableCollection entities) { getOfy().save().entities(entities); } @Override - public void saveNewOrUpdate(Object entity) { + public void put(Object entity) { saveEntity(entity); } @Override - public void saveNewOrUpdateAll(ImmutableCollection entities) { + public void putAll(ImmutableCollection entities) { getOfy().save().entities(entities); } @@ -131,12 +131,12 @@ public class DatastoreTransactionManager implements TransactionManager { } @Override - public boolean checkExists(Object entity) { + public boolean exists(Object entity) { return getOfy().load().key(Key.create(entity)).now() != null; } @Override - public boolean checkExists(VKey key) { + public boolean exists(VKey key) { return loadNullable(key) != null; } diff --git a/core/src/main/java/google/registry/model/registry/label/ReservedListDualWriteDao.java b/core/src/main/java/google/registry/model/registry/label/ReservedListDualWriteDao.java index 5ce62c83e..361c1a22a 100644 --- a/core/src/main/java/google/registry/model/registry/label/ReservedListDualWriteDao.java +++ b/core/src/main/java/google/registry/model/registry/label/ReservedListDualWriteDao.java @@ -43,7 +43,7 @@ public class ReservedListDualWriteDao { /** Persist a new reserved list to Cloud SQL. */ public static void save(ReservedList reservedList) { - ofyTm().transact(() -> ofyTm().saveNewOrUpdate(reservedList)); + ofyTm().transact(() -> ofyTm().put(reservedList)); try { logger.atInfo().log("Saving reserved list %s to Cloud SQL", reservedList.getName()); ReservedListSqlDao.save(reservedList); diff --git a/core/src/main/java/google/registry/model/registry/label/ReservedListSqlDao.java b/core/src/main/java/google/registry/model/registry/label/ReservedListSqlDao.java index 26b61e220..00936854c 100644 --- a/core/src/main/java/google/registry/model/registry/label/ReservedListSqlDao.java +++ b/core/src/main/java/google/registry/model/registry/label/ReservedListSqlDao.java @@ -31,7 +31,7 @@ public class ReservedListSqlDao { /** Persist a new reserved list to Cloud SQL. */ public static void save(ReservedList reservedList) { checkArgumentNotNull(reservedList, "Must specify reservedList"); - jpaTm().transact(() -> jpaTm().saveNew(reservedList)); + jpaTm().transact(() -> jpaTm().insert(reservedList)); } /** diff --git a/core/src/main/java/google/registry/persistence/transaction/JpaTransactionManagerImpl.java b/core/src/main/java/google/registry/persistence/transaction/JpaTransactionManagerImpl.java index 912448766..457b4fd28 100644 --- a/core/src/main/java/google/registry/persistence/transaction/JpaTransactionManagerImpl.java +++ b/core/src/main/java/google/registry/persistence/transaction/JpaTransactionManagerImpl.java @@ -224,7 +224,7 @@ public class JpaTransactionManagerImpl implements JpaTransactionManager { } @Override - public void saveNew(Object entity) { + public void insert(Object entity) { checkArgumentNotNull(entity, "entity must be specified"); assertInTransaction(); getEntityManager().persist(entity); @@ -232,14 +232,14 @@ public class JpaTransactionManagerImpl implements JpaTransactionManager { } @Override - public void saveAllNew(ImmutableCollection entities) { + public void insertAll(ImmutableCollection entities) { checkArgumentNotNull(entities, "entities must be specified"); assertInTransaction(); - entities.forEach(this::saveNew); + entities.forEach(this::insert); } @Override - public void saveNewOrUpdate(Object entity) { + public void put(Object entity) { checkArgumentNotNull(entity, "entity must be specified"); assertInTransaction(); getEntityManager().merge(entity); @@ -247,17 +247,17 @@ public class JpaTransactionManagerImpl implements JpaTransactionManager { } @Override - public void saveNewOrUpdateAll(ImmutableCollection entities) { + public void putAll(ImmutableCollection entities) { checkArgumentNotNull(entities, "entities must be specified"); assertInTransaction(); - entities.forEach(this::saveNewOrUpdate); + entities.forEach(this::put); } @Override public void update(Object entity) { checkArgumentNotNull(entity, "entity must be specified"); assertInTransaction(); - checkArgument(checkExists(entity), "Given entity does not exist"); + checkArgument(exists(entity), "Given entity does not exist"); getEntityManager().merge(entity); transactionInfo.get().addUpdate(entity); } @@ -270,22 +270,22 @@ public class JpaTransactionManagerImpl implements JpaTransactionManager { } @Override - public boolean checkExists(VKey key) { + public boolean exists(VKey key) { checkArgumentNotNull(key, "key must be specified"); EntityType entityType = getEntityType(key.getKind()); ImmutableSet entityIds = getEntityIdsFromSqlKey(entityType, key.getSqlKey()); - return checkExists(entityType.getName(), entityIds); + return exists(entityType.getName(), entityIds); } @Override - public boolean checkExists(Object entity) { + public boolean exists(Object entity) { checkArgumentNotNull(entity, "entity must be specified"); EntityType entityType = getEntityType(entity.getClass()); ImmutableSet entityIds = getEntityIdsFromEntity(entityType, entity); - return checkExists(entityType.getName(), entityIds); + return exists(entityType.getName(), entityIds); } - private boolean checkExists(String entityName, ImmutableSet entityIds) { + private boolean exists(String entityName, ImmutableSet entityIds) { assertInTransaction(); TypedQuery query = getEntityManager() diff --git a/core/src/main/java/google/registry/persistence/transaction/Transaction.java b/core/src/main/java/google/registry/persistence/transaction/Transaction.java index 8c66d6d95..01a6f32e5 100644 --- a/core/src/main/java/google/registry/persistence/transaction/Transaction.java +++ b/core/src/main/java/google/registry/persistence/transaction/Transaction.java @@ -208,7 +208,7 @@ public class Transaction extends ImmutableObject implements Buildable { @Override public void writeToDatastore() { - ofyTm().saveNewOrUpdate(entity); + ofyTm().put(entity); } @Override diff --git a/core/src/main/java/google/registry/persistence/transaction/TransactionManager.java b/core/src/main/java/google/registry/persistence/transaction/TransactionManager.java index 89f453959..82f747c44 100644 --- a/core/src/main/java/google/registry/persistence/transaction/TransactionManager.java +++ b/core/src/main/java/google/registry/persistence/transaction/TransactionManager.java @@ -86,16 +86,16 @@ public interface TransactionManager { DateTime getTransactionTime(); /** Persists a new entity in the database, throws exception if the entity already exists. */ - void saveNew(Object entity); + void insert(Object entity); /** Persists all new entities in the database, throws exception if any entity already exists. */ - void saveAllNew(ImmutableCollection entities); + void insertAll(ImmutableCollection entities); /** Persists a new entity or update the existing entity in the database. */ - void saveNewOrUpdate(Object entity); + void put(Object entity); /** Persists all new entities or update the existing entities in the database. */ - void saveNewOrUpdateAll(ImmutableCollection entities); + void putAll(ImmutableCollection entities); /** Updates an entity in the database, throws exception if the entity does not exist. */ void update(Object entity); @@ -104,10 +104,10 @@ public interface TransactionManager { void updateAll(ImmutableCollection entities); /** Returns whether the given entity with same ID exists. */ - boolean checkExists(Object entity); + boolean exists(Object entity); /** Returns whether the entity of given key exists. */ - boolean checkExists(VKey key); + boolean exists(VKey key); /** Loads the entity by its id, returns empty if the entity doesn't exist. */ Optional maybeLoad(VKey key); diff --git a/core/src/main/java/google/registry/tools/CreateRegistrarCommand.java b/core/src/main/java/google/registry/tools/CreateRegistrarCommand.java index 563615f4b..210dbce22 100644 --- a/core/src/main/java/google/registry/tools/CreateRegistrarCommand.java +++ b/core/src/main/java/google/registry/tools/CreateRegistrarCommand.java @@ -72,7 +72,7 @@ final class CreateRegistrarCommand extends CreateOrUpdateRegistrarCommand @Override void saveToCloudSql(Registrar registrar) { - jpaTm().saveNew(registrar); + jpaTm().insert(registrar); } @Nullable diff --git a/core/src/test/java/google/registry/beam/initsql/WriteToSqlTest.java b/core/src/test/java/google/registry/beam/initsql/WriteToSqlTest.java index 51eb1efe8..d4b793a5b 100644 --- a/core/src/test/java/google/registry/beam/initsql/WriteToSqlTest.java +++ b/core/src/test/java/google/registry/beam/initsql/WriteToSqlTest.java @@ -85,7 +85,7 @@ class WriteToSqlTest implements Serializable { // Required for contacts created below. Registrar ofyRegistrar = AppEngineExtension.makeRegistrar2(); store.insertOrUpdate(ofyRegistrar); - jpaTm().transact(() -> jpaTm().saveNewOrUpdate(store.loadAsOfyEntity(ofyRegistrar))); + jpaTm().transact(() -> jpaTm().put(store.loadAsOfyEntity(ofyRegistrar))); ImmutableList.Builder builder = new ImmutableList.Builder<>(); diff --git a/core/src/test/java/google/registry/beam/spec11/Spec11PipelineTest.java b/core/src/test/java/google/registry/beam/spec11/Spec11PipelineTest.java index 4ade41af2..068581a63 100644 --- a/core/src/test/java/google/registry/beam/spec11/Spec11PipelineTest.java +++ b/core/src/test/java/google/registry/beam/spec11/Spec11PipelineTest.java @@ -285,7 +285,7 @@ class Spec11PipelineTest { .build(); verify(mockJpaTm).transact(any(Runnable.class)); - verify(mockJpaTm).saveNew(expected); + verify(mockJpaTm).insert(expected); verifyNoMoreInteractions(mockJpaTm); } diff --git a/core/src/test/java/google/registry/model/billing/BillingEventTest.java b/core/src/test/java/google/registry/model/billing/BillingEventTest.java index acf22bb76..c42e0f915 100644 --- a/core/src/test/java/google/registry/model/billing/BillingEventTest.java +++ b/core/src/test/java/google/registry/model/billing/BillingEventTest.java @@ -180,7 +180,7 @@ public class BillingEventTest extends EntityTestCase { private void saveNewBillingEvent(BillingEvent billingEvent) { billingEvent.id = null; - jpaTm().transact(() -> jpaTm().saveNew(billingEvent)); + jpaTm().transact(() -> jpaTm().insert(billingEvent)); } @Test diff --git a/core/src/test/java/google/registry/model/contact/ContactResourceTest.java b/core/src/test/java/google/registry/model/contact/ContactResourceTest.java index f1037754e..eb69854ae 100644 --- a/core/src/test/java/google/registry/model/contact/ContactResourceTest.java +++ b/core/src/test/java/google/registry/model/contact/ContactResourceTest.java @@ -124,7 +124,7 @@ public class ContactResourceTest extends EntityTestCase { @Test void testCloudSqlPersistence_failWhenViolateForeignKeyConstraint() { - assertThrowForeignKeyViolation(() -> jpaTm().transact(() -> jpaTm().saveNew(originalContact))); + assertThrowForeignKeyViolation(() -> jpaTm().transact(() -> jpaTm().insert(originalContact))); } @Test @@ -134,7 +134,7 @@ public class ContactResourceTest extends EntityTestCase { saveRegistrar("registrar3"); saveRegistrar("gaining"); saveRegistrar("losing"); - jpaTm().transact(() -> jpaTm().saveNew(originalContact)); + jpaTm().transact(() -> jpaTm().insert(originalContact)); ContactResource persisted = jpaTm() .transact( diff --git a/core/src/test/java/google/registry/model/domain/DomainBaseSqlTest.java b/core/src/test/java/google/registry/model/domain/DomainBaseSqlTest.java index 1957534a0..d893add3b 100644 --- a/core/src/test/java/google/registry/model/domain/DomainBaseSqlTest.java +++ b/core/src/test/java/google/registry/model/domain/DomainBaseSqlTest.java @@ -139,9 +139,9 @@ public class DomainBaseSqlTest { .transact( () -> { // Persist the domain without the associated host object. - jpaTm().saveNew(contact); - jpaTm().saveNew(contact2); - jpaTm().saveNew(domain); + jpaTm().insert(contact); + jpaTm().insert(contact2); + jpaTm().insert(domain); })); } @@ -153,8 +153,8 @@ public class DomainBaseSqlTest { .transact( () -> { // Persist the domain without the associated contact objects. - jpaTm().saveNew(domain); - jpaTm().saveNew(host); + jpaTm().insert(domain); + jpaTm().insert(host); })); } @@ -165,7 +165,7 @@ public class DomainBaseSqlTest { .transact( () -> { DomainBase persisted = jpaTm().load(domain.createVKey()); - jpaTm().saveNewOrUpdate(persisted.asBuilder().build()); + jpaTm().put(persisted.asBuilder().build()); }); jpaTm() .transact( @@ -185,7 +185,7 @@ public class DomainBaseSqlTest { DomainBase persisted = jpaTm().load(domain.createVKey()); DomainBase modified = persisted.asBuilder().setGracePeriods(ImmutableSet.of()).build(); - jpaTm().saveNewOrUpdate(modified); + jpaTm().put(modified); }); jpaTm() @@ -204,7 +204,7 @@ public class DomainBaseSqlTest { () -> { DomainBase persisted = jpaTm().load(domain.createVKey()); DomainBase modified = persisted.asBuilder().setGracePeriods(null).build(); - jpaTm().saveNewOrUpdate(modified); + jpaTm().put(modified); }); jpaTm() @@ -229,7 +229,7 @@ public class DomainBaseSqlTest { GracePeriod.create( GracePeriodStatus.RENEW, "4-COM", END_OF_TIME, "registrar1", null)) .build(); - jpaTm().saveNewOrUpdate(modified); + jpaTm().put(modified); }); jpaTm() @@ -281,7 +281,7 @@ public class DomainBaseSqlTest { builder.removeGracePeriod(gracePeriod); } } - jpaTm().saveNewOrUpdate(builder.build()); + jpaTm().put(builder.build()); }); jpaTm() @@ -301,7 +301,7 @@ public class DomainBaseSqlTest { DomainBase persisted = jpaTm().load(domain.createVKey()); DomainBase modified = persisted.asBuilder().setGracePeriods(ImmutableSet.of()).build(); - jpaTm().saveNewOrUpdate(modified); + jpaTm().put(modified); }); jpaTm() @@ -316,7 +316,7 @@ public class DomainBaseSqlTest { GracePeriod.create( GracePeriodStatus.ADD, "4-COM", END_OF_TIME, "registrar1", null)) .build(); - jpaTm().saveNewOrUpdate(modified); + jpaTm().put(modified); }); jpaTm() @@ -339,13 +339,13 @@ public class DomainBaseSqlTest { jpaTm() .transact( () -> { - jpaTm().saveNew(contact); - jpaTm().saveNew(contact2); - jpaTm().saveNew(domain); - jpaTm().saveNew(host); + jpaTm().insert(contact); + jpaTm().insert(contact2); + jpaTm().insert(domain); + jpaTm().insert(host); }); domain = domain.asBuilder().setNameservers(ImmutableSet.of()).build(); - jpaTm().transact(() -> jpaTm().saveNewOrUpdate(domain)); + jpaTm().transact(() -> jpaTm().put(domain)); jpaTm() .transact( () -> { @@ -382,16 +382,16 @@ public class DomainBaseSqlTest { // Persist the contacts. Note that these need to be persisted before the domain // otherwise we get a foreign key constraint error. If we ever decide to defer the // relevant foreign key checks to commit time, then the order would not matter. - jpaTm().saveNew(contact); - jpaTm().saveNew(contact2); + jpaTm().insert(contact); + jpaTm().insert(contact2); // Persist the domain. - jpaTm().saveNew(domain); + jpaTm().insert(domain); // Persist the host. This does _not_ need to be persisted before the domain, // because only the row in the join table (DomainHost) is subject to foreign key // constraints, and Hibernate knows to insert it after domain and host. - jpaTm().saveNew(host); + jpaTm().insert(host); }); } diff --git a/core/src/test/java/google/registry/model/domain/token/AllocationTokenTest.java b/core/src/test/java/google/registry/model/domain/token/AllocationTokenTest.java index 455b69806..1dc7bae67 100644 --- a/core/src/test/java/google/registry/model/domain/token/AllocationTokenTest.java +++ b/core/src/test/java/google/registry/model/domain/token/AllocationTokenTest.java @@ -95,8 +95,8 @@ public class AllocationTokenTest extends EntityTestCase { jpaTm() .transact( () -> { - jpaTm().saveNew(unlimitedUseToken); - jpaTm().saveNew(singleUseToken); + jpaTm().insert(unlimitedUseToken); + jpaTm().insert(singleUseToken); }); jpaTm() .transact( diff --git a/core/src/test/java/google/registry/model/history/ContactHistoryTest.java b/core/src/test/java/google/registry/model/history/ContactHistoryTest.java index 743dfaaff..88e6f02eb 100644 --- a/core/src/test/java/google/registry/model/history/ContactHistoryTest.java +++ b/core/src/test/java/google/registry/model/history/ContactHistoryTest.java @@ -44,12 +44,12 @@ public class ContactHistoryTest extends EntityTestCase { saveRegistrar("TheRegistrar"); ContactResource contact = newContactResourceWithRoid("contactId", "contact1"); - jpaTm().transact(() -> jpaTm().saveNew(contact)); + jpaTm().transact(() -> jpaTm().insert(contact)); VKey contactVKey = contact.createVKey(); ContactResource contactFromDb = jpaTm().transact(() -> jpaTm().load(contactVKey)); ContactHistory contactHistory = createContactHistory(contactFromDb, contactVKey); contactHistory.id = null; - jpaTm().transact(() -> jpaTm().saveNew(contactHistory)); + jpaTm().transact(() -> jpaTm().insert(contactHistory)); jpaTm() .transact( () -> { @@ -65,12 +65,12 @@ public class ContactHistoryTest extends EntityTestCase { saveRegistrar("TheRegistrar"); ContactResource contact = newContactResourceWithRoid("contactId", "contact1"); - tm().transact(() -> tm().saveNew(contact)); + tm().transact(() -> tm().insert(contact)); VKey contactVKey = contact.createVKey(); ContactResource contactFromDb = tm().transact(() -> tm().load(contactVKey)); fakeClock.advanceOneMilli(); ContactHistory contactHistory = createContactHistory(contactFromDb, contactVKey); - tm().transact(() -> tm().saveNew(contactHistory)); + tm().transact(() -> tm().insert(contactHistory)); // retrieving a HistoryEntry or a ContactHistory with the same key should return the same object // note: due to the @EntitySubclass annotation. all Keys for ContactHistory objects will have diff --git a/core/src/test/java/google/registry/model/history/DomainHistoryTest.java b/core/src/test/java/google/registry/model/history/DomainHistoryTest.java index 3082a797d..f46347ba7 100644 --- a/core/src/test/java/google/registry/model/history/DomainHistoryTest.java +++ b/core/src/test/java/google/registry/model/history/DomainHistoryTest.java @@ -59,8 +59,8 @@ public class DomainHistoryTest extends EntityTestCase { jpaTm() .transact( () -> { - jpaTm().saveNew(host); - jpaTm().saveNew(contact); + jpaTm().insert(host); + jpaTm().insert(contact); }); DomainBase domain = @@ -68,11 +68,11 @@ public class DomainHistoryTest extends EntityTestCase { .asBuilder() .setNameservers(host.createVKey()) .build(); - jpaTm().transact(() -> jpaTm().saveNew(domain)); + jpaTm().transact(() -> jpaTm().insert(domain)); DomainHistory domainHistory = createDomainHistory(domain); domainHistory.id = null; - jpaTm().transact(() -> jpaTm().saveNew(domainHistory)); + jpaTm().transact(() -> jpaTm().insert(domainHistory)); jpaTm() .transact( @@ -98,8 +98,8 @@ public class DomainHistoryTest extends EntityTestCase { tm().transact( () -> { - tm().saveNew(host); - tm().saveNew(contact); + tm().insert(host); + tm().insert(contact); }); fakeClock.advanceOneMilli(); @@ -108,11 +108,11 @@ public class DomainHistoryTest extends EntityTestCase { .asBuilder() .setNameservers(host.createVKey()) .build(); - tm().transact(() -> tm().saveNew(domain)); + tm().transact(() -> tm().insert(domain)); fakeClock.advanceOneMilli(); DomainHistory domainHistory = createDomainHistory(domain); - tm().transact(() -> tm().saveNew(domainHistory)); + tm().transact(() -> tm().insert(domainHistory)); // retrieving a HistoryEntry or a DomainHistory with the same key should return the same object // note: due to the @EntitySubclass annotation. all Keys for ContactHistory objects will have diff --git a/core/src/test/java/google/registry/model/history/HostHistoryTest.java b/core/src/test/java/google/registry/model/history/HostHistoryTest.java index 3593ab53b..660779115 100644 --- a/core/src/test/java/google/registry/model/history/HostHistoryTest.java +++ b/core/src/test/java/google/registry/model/history/HostHistoryTest.java @@ -44,12 +44,12 @@ public class HostHistoryTest extends EntityTestCase { saveRegistrar("TheRegistrar"); HostResource host = newHostResourceWithRoid("ns1.example.com", "host1"); - jpaTm().transact(() -> jpaTm().saveNew(host)); + jpaTm().transact(() -> jpaTm().insert(host)); VKey hostVKey = VKey.createSql(HostResource.class, "host1"); HostResource hostFromDb = jpaTm().transact(() -> jpaTm().load(hostVKey)); HostHistory hostHistory = createHostHistory(hostFromDb, hostVKey); hostHistory.id = null; - jpaTm().transact(() -> jpaTm().saveNew(hostHistory)); + jpaTm().transact(() -> jpaTm().insert(hostHistory)); jpaTm() .transact( () -> { @@ -66,12 +66,12 @@ public class HostHistoryTest extends EntityTestCase { saveRegistrar("registrar1"); HostResource host = newHostResourceWithRoid("ns1.example.com", "host1"); - tm().transact(() -> tm().saveNew(host)); + tm().transact(() -> tm().insert(host)); VKey hostVKey = VKey.create(HostResource.class, "host1", Key.create(host)); HostResource hostFromDb = tm().transact(() -> tm().load(hostVKey)); HostHistory hostHistory = createHostHistory(hostFromDb, hostVKey); fakeClock.advanceOneMilli(); - tm().transact(() -> tm().saveNew(hostHistory)); + tm().transact(() -> tm().insert(hostHistory)); // retrieving a HistoryEntry or a HostHistory with the same key should return the same object // note: due to the @EntitySubclass annotation. all Keys for ContactHistory objects will have diff --git a/core/src/test/java/google/registry/model/poll/PollMessageTest.java b/core/src/test/java/google/registry/model/poll/PollMessageTest.java index 787966114..24c84fa90 100644 --- a/core/src/test/java/google/registry/model/poll/PollMessageTest.java +++ b/core/src/test/java/google/registry/model/poll/PollMessageTest.java @@ -84,7 +84,7 @@ public class PollMessageTest extends EntityTestCase { @Test void testCloudSqlPersistenceOneTime() { saveRegistrar("TheRegistrar"); - jpaTm().transact(() -> jpaTm().saveNew(oneTime)); + jpaTm().transact(() -> jpaTm().insert(oneTime)); PollMessage.OneTime persisted = jpaTm().transact(() -> jpaTm().load(VKey.createSql(PollMessage.OneTime.class, oneTime.id))); persisted.parent = oneTime.parent; @@ -94,7 +94,7 @@ public class PollMessageTest extends EntityTestCase { @Test void testCloudSqlPersistenceAutorenew() { saveRegistrar("TheRegistrar"); - jpaTm().transact(() -> jpaTm().saveNew(autoRenew)); + jpaTm().transact(() -> jpaTm().insert(autoRenew)); PollMessage.Autorenew persisted = jpaTm() .transact( @@ -107,14 +107,14 @@ public class PollMessageTest extends EntityTestCase { void testCloudSqlSupportForPolymorphicVKey() { saveRegistrar("TheRegistrar"); - jpaTm().transact(() -> jpaTm().saveNew(oneTime)); + jpaTm().transact(() -> jpaTm().insert(oneTime)); PollMessage persistedOneTime = jpaTm().transact(() -> jpaTm().load(VKey.createSql(PollMessage.class, oneTime.getId()))); assertThat(persistedOneTime).isInstanceOf(PollMessage.OneTime.class); persistedOneTime.parent = oneTime.parent; assertThat(persistedOneTime).isEqualTo(oneTime); - jpaTm().transact(() -> jpaTm().saveNew(autoRenew)); + jpaTm().transact(() -> jpaTm().insert(autoRenew)); PollMessage persistedAutoRenew = jpaTm().transact(() -> jpaTm().load(VKey.createSql(PollMessage.class, autoRenew.getId()))); assertThat(persistedAutoRenew).isInstanceOf(PollMessage.Autorenew.class); diff --git a/core/src/test/java/google/registry/model/registry/RegistryTest.java b/core/src/test/java/google/registry/model/registry/RegistryTest.java index 12ed870f0..f7d686bea 100644 --- a/core/src/test/java/google/registry/model/registry/RegistryTest.java +++ b/core/src/test/java/google/registry/model/registry/RegistryTest.java @@ -72,7 +72,7 @@ public class RegistryTest extends EntityTestCase { PremiumList pl = persistPremiumList("tld2", "lol,USD 50", "cat,USD 700"); Registry registry = Registry.get("tld").asBuilder().setReservedLists(rl15).setPremiumList(pl).build(); - jpaTm().transact(() -> jpaTm().saveNew(registry)); + jpaTm().transact(() -> jpaTm().insert(registry)); Registry persisted = jpaTm().transact(() -> jpaTm().load(VKey.createSql(Registry.class, registry.tldStrId))); assertThat(persisted).isEqualTo(registry); diff --git a/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchDaoTest.java b/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchDaoTest.java index 56875304d..7ff9387b2 100644 --- a/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchDaoTest.java +++ b/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchDaoTest.java @@ -37,8 +37,8 @@ public class Spec11ThreatMatchDaoTest extends EntityTestCase { jpaTm() .transact( () -> { - jpaTm().saveAllNew(getThreatMatchesToday()); - jpaTm().saveAllNew(getThreatMatchesYesterday()); + jpaTm().insertAll(getThreatMatchesToday()); + jpaTm().insertAll(getThreatMatchesYesterday()); }); } diff --git a/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchTest.java b/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchTest.java index fd4d04bfa..e4ee76a54 100644 --- a/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchTest.java +++ b/core/src/test/java/google/registry/model/reporting/Spec11ThreatMatchTest.java @@ -107,10 +107,10 @@ public class Spec11ThreatMatchTest extends EntityTestCase { jpaTm() .transact( () -> { - jpaTm().saveNew(registrantContact); - jpaTm().saveNew(domain); - jpaTm().saveNew(host); - jpaTm().saveNew(threat); + jpaTm().insert(registrantContact); + jpaTm().insert(domain); + jpaTm().insert(host); + jpaTm().insert(threat); }); VKey threatVKey = VKey.createSql(Spec11ThreatMatch.class, threat.getId()); @@ -130,10 +130,10 @@ public class Spec11ThreatMatchTest extends EntityTestCase { .transact( () -> { // Persist the threat without the associated registrar. - jpaTm().saveNew(host); - jpaTm().saveNew(registrantContact); - jpaTm().saveNew(domain); - jpaTm().saveNew(threat); + jpaTm().insert(host); + jpaTm().insert(registrantContact); + jpaTm().insert(domain); + jpaTm().insert(threat); }); }); @@ -145,9 +145,9 @@ public class Spec11ThreatMatchTest extends EntityTestCase { .transact( () -> { // Persist the threat without the associated domain. - jpaTm().saveNew(registrantContact); - jpaTm().saveNew(host); - jpaTm().saveNew(threat); + jpaTm().insert(registrantContact); + jpaTm().insert(host); + jpaTm().insert(threat); }); }); } diff --git a/core/src/test/java/google/registry/persistence/EntityCallbacksListenerTest.java b/core/src/test/java/google/registry/persistence/EntityCallbacksListenerTest.java index fc3e6545b..43cc58b49 100644 --- a/core/src/test/java/google/registry/persistence/EntityCallbacksListenerTest.java +++ b/core/src/test/java/google/registry/persistence/EntityCallbacksListenerTest.java @@ -49,7 +49,7 @@ class EntityCallbacksListenerTest { @Test void verifyAllCallbacks_executedExpectedTimes() { TestEntity testPersist = new TestEntity(); - jpaTm().transact(() -> jpaTm().saveNew(testPersist)); + jpaTm().transact(() -> jpaTm().insert(testPersist)); checkAll(testPersist, 1, 0, 0, 0); TestEntity testUpdate = new TestEntity(); diff --git a/core/src/test/java/google/registry/persistence/converter/DurationConverterTest.java b/core/src/test/java/google/registry/persistence/converter/DurationConverterTest.java index bfcd4e676..d9f4bc735 100644 --- a/core/src/test/java/google/registry/persistence/converter/DurationConverterTest.java +++ b/core/src/test/java/google/registry/persistence/converter/DurationConverterTest.java @@ -78,7 +78,7 @@ public class DurationConverterTest { private void assertPersistedEntityHasSameDuration(Duration duration) { DurationTestEntity entity = new DurationTestEntity(duration); - jpaTm().transact(() -> jpaTm().saveNew(entity)); + jpaTm().transact(() -> jpaTm().insert(entity)); DurationTestEntity persisted = jpaTm().transact(() -> jpaTm().getEntityManager().find(DurationTestEntity.class, "id")); assertThat(persisted.duration.getMillis()).isEqualTo(duration.getMillis()); diff --git a/core/src/test/java/google/registry/persistence/converter/InetAddressSetConverterTest.java b/core/src/test/java/google/registry/persistence/converter/InetAddressSetConverterTest.java index 203325def..173b5293d 100644 --- a/core/src/test/java/google/registry/persistence/converter/InetAddressSetConverterTest.java +++ b/core/src/test/java/google/registry/persistence/converter/InetAddressSetConverterTest.java @@ -63,7 +63,7 @@ public class InetAddressSetConverterTest { private void verifySaveAndLoad(@Nullable Set inetAddresses) { InetAddressSetTestEntity testEntity = new InetAddressSetTestEntity(inetAddresses); - jpaTm().transact(() -> jpaTm().saveNew(testEntity)); + jpaTm().transact(() -> jpaTm().insert(testEntity)); InetAddressSetTestEntity persisted = jpaTm().transact(() -> jpaTm().load(VKey.createSql(InetAddressSetTestEntity.class, "id"))); assertThat(persisted.addresses).isEqualTo(inetAddresses); diff --git a/core/src/test/java/google/registry/persistence/converter/LocalDateConverterTest.java b/core/src/test/java/google/registry/persistence/converter/LocalDateConverterTest.java index 257e8f881..8b6583474 100644 --- a/core/src/test/java/google/registry/persistence/converter/LocalDateConverterTest.java +++ b/core/src/test/java/google/registry/persistence/converter/LocalDateConverterTest.java @@ -54,7 +54,7 @@ public class LocalDateConverterTest { private LocalDateConverterTestEntity persistAndLoadTestEntity(LocalDate date) { LocalDateConverterTestEntity entity = new LocalDateConverterTestEntity(date); - jpaTm().transact(() -> jpaTm().saveNew(entity)); + jpaTm().transact(() -> jpaTm().insert(entity)); LocalDateConverterTestEntity retrievedEntity = jpaTm() .transact(() -> jpaTm().load(VKey.createSql(LocalDateConverterTestEntity.class, "id"))); diff --git a/core/src/test/java/google/registry/persistence/transaction/JpaTransactionManagerImplTest.java b/core/src/test/java/google/registry/persistence/transaction/JpaTransactionManagerImplTest.java index 5daa39f50..15ef8f521 100644 --- a/core/src/test/java/google/registry/persistence/transaction/JpaTransactionManagerImplTest.java +++ b/core/src/test/java/google/registry/persistence/transaction/JpaTransactionManagerImplTest.java @@ -132,10 +132,10 @@ class JpaTransactionManagerImplTest { } @Test - void saveNew_succeeds() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(theEntity)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isTrue(); + void insert_succeeds() { + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(theEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isTrue(); assertThat(jpaTm().transact(() -> jpaTm().load(theEntityKey))).isEqualTo(theEntity); } @@ -143,7 +143,7 @@ class JpaTransactionManagerImplTest { void transact_retriesOptimisticLockExceptions() { JpaTransactionManager spyJpaTm = spy(jpaTm()); doThrow(OptimisticLockException.class).when(spyJpaTm).delete(any(VKey.class)); - spyJpaTm.transact(() -> spyJpaTm.saveNew(theEntity)); + spyJpaTm.transact(() -> spyJpaTm.insert(theEntity)); assertThrows( OptimisticLockException.class, () -> spyJpaTm.transact(() -> spyJpaTm.delete(theEntityKey))); @@ -162,7 +162,7 @@ class JpaTransactionManagerImplTest { void transactNoRetry_doesNotRetryOptimisticLockException() { JpaTransactionManager spyJpaTm = spy(jpaTm()); doThrow(OptimisticLockException.class).when(spyJpaTm).delete(any(VKey.class)); - spyJpaTm.transactNoRetry(() -> spyJpaTm.saveNew(theEntity)); + spyJpaTm.transactNoRetry(() -> spyJpaTm.insert(theEntity)); assertThrows( OptimisticLockException.class, () -> spyJpaTm.transactNoRetry(() -> spyJpaTm.delete(theEntityKey))); @@ -183,7 +183,7 @@ class JpaTransactionManagerImplTest { doThrow(new RuntimeException().initCause(new OptimisticLockException())) .when(spyJpaTm) .delete(any(VKey.class)); - spyJpaTm.transact(() -> spyJpaTm.saveNew(theEntity)); + spyJpaTm.transact(() -> spyJpaTm.insert(theEntity)); assertThrows( RuntimeException.class, () -> spyJpaTm.transact(() -> spyJpaTm.delete(theEntityKey))); verify(spyJpaTm, times(3)).delete(theEntityKey); @@ -201,7 +201,7 @@ class JpaTransactionManagerImplTest { void transactNewReadOnly_retriesJdbcConnectionExceptions() { JpaTransactionManager spyJpaTm = spy(jpaTm()); doThrow(JDBCConnectionException.class).when(spyJpaTm).load(any(VKey.class)); - spyJpaTm.transact(() -> spyJpaTm.saveNew(theEntity)); + spyJpaTm.transact(() -> spyJpaTm.insert(theEntity)); assertThrows( JDBCConnectionException.class, () -> spyJpaTm.transactNewReadOnly(() -> spyJpaTm.load(theEntityKey))); @@ -224,7 +224,7 @@ class JpaTransactionManagerImplTest { .initCause(new JDBCConnectionException("connection exception", new SQLException()))) .when(spyJpaTm) .load(any(VKey.class)); - spyJpaTm.transact(() -> spyJpaTm.saveNew(theEntity)); + spyJpaTm.transact(() -> spyJpaTm.insert(theEntity)); assertThrows( RuntimeException.class, () -> spyJpaTm.transactNewReadOnly(() -> spyJpaTm.load(theEntityKey))); @@ -243,7 +243,7 @@ class JpaTransactionManagerImplTest { void doTransactionless_retriesJdbcConnectionExceptions() { JpaTransactionManager spyJpaTm = spy(jpaTm()); doThrow(JDBCConnectionException.class).when(spyJpaTm).load(any(VKey.class)); - spyJpaTm.transact(() -> spyJpaTm.saveNew(theEntity)); + spyJpaTm.transact(() -> spyJpaTm.insert(theEntity)); assertThrows( RuntimeException.class, () -> spyJpaTm.doTransactionless(() -> spyJpaTm.load(theEntityKey))); @@ -251,19 +251,19 @@ class JpaTransactionManagerImplTest { } @Test - void saveNew_throwsExceptionIfEntityExists() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(theEntity)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isTrue(); + void insert_throwsExceptionIfEntityExists() { + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(theEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isTrue(); assertThat(jpaTm().transact(() -> jpaTm().load(theEntityKey))).isEqualTo(theEntity); - assertThrows(RollbackException.class, () -> jpaTm().transact(() -> jpaTm().saveNew(theEntity))); + assertThrows(RollbackException.class, () -> jpaTm().transact(() -> jpaTm().insert(theEntity))); } @Test void createCompoundIdEntity_succeeds() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(compoundIdEntity))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(compoundIdEntity)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(compoundIdEntity))).isTrue(); + assertThat(jpaTm().transact(() -> jpaTm().exists(compoundIdEntity))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(compoundIdEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(compoundIdEntity))).isTrue(); assertThat(jpaTm().transact(() -> jpaTm().load(compoundIdEntityKey))) .isEqualTo(compoundIdEntity); } @@ -271,10 +271,10 @@ class JpaTransactionManagerImplTest { @Test void saveAllNew_succeeds() { moreEntities.forEach( - entity -> assertThat(jpaTm().transact(() -> jpaTm().checkExists(entity))).isFalse()); - jpaTm().transact(() -> jpaTm().saveAllNew(moreEntities)); + entity -> assertThat(jpaTm().transact(() -> jpaTm().exists(entity))).isFalse()); + jpaTm().transact(() -> jpaTm().insertAll(moreEntities)); moreEntities.forEach( - entity -> assertThat(jpaTm().transact(() -> jpaTm().checkExists(entity))).isTrue()); + entity -> assertThat(jpaTm().transact(() -> jpaTm().exists(entity))).isTrue()); assertThat(jpaTm().transact(() -> jpaTm().loadAll(TestEntity.class))) .containsExactlyElementsIn(moreEntities); } @@ -282,48 +282,48 @@ class JpaTransactionManagerImplTest { @Test void saveAllNew_rollsBackWhenFailure() { moreEntities.forEach( - entity -> assertThat(jpaTm().transact(() -> jpaTm().checkExists(entity))).isFalse()); - jpaTm().transact(() -> jpaTm().saveNew(moreEntities.get(0))); + entity -> assertThat(jpaTm().transact(() -> jpaTm().exists(entity))).isFalse()); + jpaTm().transact(() -> jpaTm().insert(moreEntities.get(0))); assertThrows( - RollbackException.class, () -> jpaTm().transact(() -> jpaTm().saveAllNew(moreEntities))); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(moreEntities.get(0)))).isTrue(); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(moreEntities.get(1)))).isFalse(); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(moreEntities.get(2)))).isFalse(); + RollbackException.class, () -> jpaTm().transact(() -> jpaTm().insertAll(moreEntities))); + assertThat(jpaTm().transact(() -> jpaTm().exists(moreEntities.get(0)))).isTrue(); + assertThat(jpaTm().transact(() -> jpaTm().exists(moreEntities.get(1)))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(moreEntities.get(2)))).isFalse(); } @Test - void saveNewOrUpdate_persistsNewEntity() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNewOrUpdate(theEntity)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isTrue(); + void put_persistsNewEntity() { + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); + jpaTm().transact(() -> jpaTm().put(theEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isTrue(); assertThat(jpaTm().transact(() -> jpaTm().load(theEntityKey))).isEqualTo(theEntity); } @Test - void saveNewOrUpdate_updatesExistingEntity() { - jpaTm().transact(() -> jpaTm().saveNew(theEntity)); + void put_updatesExistingEntity() { + jpaTm().transact(() -> jpaTm().insert(theEntity)); TestEntity persisted = jpaTm().transact(() -> jpaTm().load(theEntityKey)); assertThat(persisted.data).isEqualTo("foo"); theEntity.data = "bar"; - jpaTm().transact(() -> jpaTm().saveNewOrUpdate(theEntity)); + jpaTm().transact(() -> jpaTm().put(theEntity)); persisted = jpaTm().transact(() -> jpaTm().load(theEntityKey)); assertThat(persisted.data).isEqualTo("bar"); } @Test - void saveNewOrUpdateAll_succeeds() { + void putAll_succeeds() { moreEntities.forEach( - entity -> assertThat(jpaTm().transact(() -> jpaTm().checkExists(entity))).isFalse()); - jpaTm().transact(() -> jpaTm().saveNewOrUpdateAll(moreEntities)); + entity -> assertThat(jpaTm().transact(() -> jpaTm().exists(entity))).isFalse()); + jpaTm().transact(() -> jpaTm().putAll(moreEntities)); moreEntities.forEach( - entity -> assertThat(jpaTm().transact(() -> jpaTm().checkExists(entity))).isTrue()); + entity -> assertThat(jpaTm().transact(() -> jpaTm().exists(entity))).isTrue()); assertThat(jpaTm().transact(() -> jpaTm().loadAll(TestEntity.class))) .containsExactlyElementsIn(moreEntities); } @Test void update_succeeds() { - jpaTm().transact(() -> jpaTm().saveNew(theEntity)); + jpaTm().transact(() -> jpaTm().insert(theEntity)); TestEntity persisted = jpaTm().transact(() -> jpaTm().load(VKey.createSql(TestEntity.class, "theEntity"))); assertThat(persisted.data).isEqualTo("foo"); @@ -335,7 +335,7 @@ class JpaTransactionManagerImplTest { @Test void updateCompoundIdEntity_succeeds() { - jpaTm().transact(() -> jpaTm().saveNew(compoundIdEntity)); + jpaTm().transact(() -> jpaTm().insert(compoundIdEntity)); TestCompoundIdEntity persisted = jpaTm().transact(() -> jpaTm().load(compoundIdEntityKey)); assertThat(persisted.data).isEqualTo("foo"); compoundIdEntity.data = "bar"; @@ -346,15 +346,15 @@ class JpaTransactionManagerImplTest { @Test void update_throwsExceptionWhenEntityDoesNotExist() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); assertThrows( IllegalArgumentException.class, () -> jpaTm().transact(() -> jpaTm().update(theEntity))); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); } @Test void updateAll_succeeds() { - jpaTm().transact(() -> jpaTm().saveAllNew(moreEntities)); + jpaTm().transact(() -> jpaTm().insertAll(moreEntities)); ImmutableList updated = ImmutableList.of( new TestEntity("entity1", "foo_updated"), @@ -367,7 +367,7 @@ class JpaTransactionManagerImplTest { @Test void updateAll_rollsBackWhenFailure() { - jpaTm().transact(() -> jpaTm().saveAllNew(moreEntities)); + jpaTm().transact(() -> jpaTm().insertAll(moreEntities)); ImmutableList updated = ImmutableList.of( new TestEntity("entity1", "foo_updated"), @@ -382,8 +382,8 @@ class JpaTransactionManagerImplTest { @Test void load_succeeds() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(theEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(theEntity)); TestEntity persisted = jpaTm().transact(() -> jpaTm().load(theEntityKey)); assertThat(persisted.name).isEqualTo("theEntity"); assertThat(persisted.data).isEqualTo("foo"); @@ -391,15 +391,15 @@ class JpaTransactionManagerImplTest { @Test void load_throwsOnMissingElement() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); assertThrows( NoSuchElementException.class, () -> jpaTm().transact(() -> jpaTm().load(theEntityKey))); } @Test void maybeLoad_succeeds() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(theEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(theEntity)); TestEntity persisted = jpaTm().transact(() -> jpaTm().maybeLoad(theEntityKey).get()); assertThat(persisted.name).isEqualTo("theEntity"); assertThat(persisted.data).isEqualTo("foo"); @@ -407,14 +407,14 @@ class JpaTransactionManagerImplTest { @Test void maybeLoad_nonExistentObject() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); assertThat(jpaTm().transact(() -> jpaTm().maybeLoad(theEntityKey)).isPresent()).isFalse(); } @Test void loadCompoundIdEntity_succeeds() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(compoundIdEntity))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(compoundIdEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(compoundIdEntity))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(compoundIdEntity)); TestCompoundIdEntity persisted = jpaTm().transact(() -> jpaTm().load(compoundIdEntityKey)); assertThat(persisted.name).isEqualTo("compoundIdEntity"); assertThat(persisted.age).isEqualTo(10); @@ -423,37 +423,37 @@ class JpaTransactionManagerImplTest { @Test void loadAll_succeeds() { - jpaTm().transact(() -> jpaTm().saveAllNew(moreEntities)); + jpaTm().transact(() -> jpaTm().insertAll(moreEntities)); ImmutableList persisted = jpaTm().transact(() -> jpaTm().loadAll(TestEntity.class)); assertThat(persisted).containsExactlyElementsIn(moreEntities); } @Test void delete_succeeds() { - jpaTm().transact(() -> jpaTm().saveNew(theEntity)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isTrue(); + jpaTm().transact(() -> jpaTm().insert(theEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isTrue(); jpaTm().transact(() -> jpaTm().delete(theEntityKey)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); } @Test void delete_returnsZeroWhenNoEntity() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); jpaTm().transact(() -> jpaTm().delete(theEntityKey)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); } @Test void deleteCompoundIdEntity_succeeds() { - jpaTm().transact(() -> jpaTm().saveNew(compoundIdEntity)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(compoundIdEntity))).isTrue(); + jpaTm().transact(() -> jpaTm().insert(compoundIdEntity)); + assertThat(jpaTm().transact(() -> jpaTm().exists(compoundIdEntity))).isTrue(); jpaTm().transact(() -> jpaTm().delete(compoundIdEntityKey)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(compoundIdEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(compoundIdEntity))).isFalse(); } @Test void assertDelete_throwsExceptionWhenEntityNotDeleted() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(theEntity))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(theEntity))).isFalse(); assertThrows( IllegalArgumentException.class, () -> jpaTm().transact(() -> jpaTm().assertDelete(theEntityKey))); diff --git a/core/src/test/java/google/registry/persistence/transaction/TransactionManagerTest.java b/core/src/test/java/google/registry/persistence/transaction/TransactionManagerTest.java index 50d6044da..4fe27c0a9 100644 --- a/core/src/test/java/google/registry/persistence/transaction/TransactionManagerTest.java +++ b/core/src/test/java/google/registry/persistence/transaction/TransactionManagerTest.java @@ -107,7 +107,7 @@ public class TransactionManagerTest { () -> tm().transact( () -> { - tm().saveNew(theEntity); + tm().insert(theEntity); throw new RuntimeException(); })); assertEntityNotExist(theEntity); @@ -116,21 +116,21 @@ public class TransactionManagerTest { @TestTemplate void transact_reusesExistingTransaction() { assertEntityNotExist(theEntity); - tm().transact(() -> tm().transact(() -> tm().saveNew(theEntity))); + tm().transact(() -> tm().transact(() -> tm().insert(theEntity))); assertEntityExists(theEntity); } @TestTemplate void transactNew_succeeds() { assertEntityNotExist(theEntity); - tm().transactNew(() -> tm().saveNew(theEntity)); + tm().transactNew(() -> tm().insert(theEntity)); assertEntityExists(theEntity); } @TestTemplate void transactNewReadOnly_succeeds() { assertEntityNotExist(theEntity); - tm().transact(() -> tm().saveNew(theEntity)); + tm().transact(() -> tm().insert(theEntity)); assertEntityExists(theEntity); TestEntity persisted = tm().transactNewReadOnly(() -> tm().load(theEntity.key())); assertThat(persisted).isEqualTo(theEntity); @@ -140,14 +140,14 @@ public class TransactionManagerTest { void transactNewReadOnly_throwsWhenWritingEntity() { assertEntityNotExist(theEntity); assertThrows( - RuntimeException.class, () -> tm().transactNewReadOnly(() -> tm().saveNew(theEntity))); + RuntimeException.class, () -> tm().transactNewReadOnly(() -> tm().insert(theEntity))); assertEntityNotExist(theEntity); } @TestTemplate void saveNew_succeeds() { assertEntityNotExist(theEntity); - tm().transact(() -> tm().saveNew(theEntity)); + tm().transact(() -> tm().insert(theEntity)); assertEntityExists(theEntity); assertThat(tm().transact(() -> tm().load(theEntity.key()))).isEqualTo(theEntity); } @@ -155,26 +155,26 @@ public class TransactionManagerTest { @TestTemplate void saveAllNew_succeeds() { assertAllEntitiesNotExist(moreEntities); - tm().transact(() -> tm().saveAllNew(moreEntities)); + tm().transact(() -> tm().insertAll(moreEntities)); assertAllEntitiesExist(moreEntities); } @TestTemplate void saveNewOrUpdate_persistsNewEntity() { assertEntityNotExist(theEntity); - tm().transact(() -> tm().saveNewOrUpdate(theEntity)); + tm().transact(() -> tm().put(theEntity)); assertEntityExists(theEntity); assertThat(tm().transact(() -> tm().load(theEntity.key()))).isEqualTo(theEntity); } @TestTemplate void saveNewOrUpdate_updatesExistingEntity() { - tm().transact(() -> tm().saveNew(theEntity)); + tm().transact(() -> tm().insert(theEntity)); TestEntity persisted = tm().transact(() -> tm().load(theEntity.key())); assertThat(persisted.data).isEqualTo("foo"); theEntity.data = "bar"; fakeClock.advanceOneMilli(); - tm().transact(() -> tm().saveNewOrUpdate(theEntity)); + tm().transact(() -> tm().put(theEntity)); persisted = tm().transact(() -> tm().load(theEntity.key())); assertThat(persisted.data).isEqualTo("bar"); } @@ -182,13 +182,13 @@ public class TransactionManagerTest { @TestTemplate void saveNewOrUpdateAll_succeeds() { assertAllEntitiesNotExist(moreEntities); - tm().transact(() -> tm().saveNewOrUpdateAll(moreEntities)); + tm().transact(() -> tm().putAll(moreEntities)); assertAllEntitiesExist(moreEntities); } @TestTemplate void update_succeeds() { - tm().transact(() -> tm().saveNew(theEntity)); + tm().transact(() -> tm().insert(theEntity)); TestEntity persisted = tm().transact( () -> @@ -205,7 +205,7 @@ public class TransactionManagerTest { @TestTemplate void load_succeeds() { assertEntityNotExist(theEntity); - tm().transact(() -> tm().saveNew(theEntity)); + tm().transact(() -> tm().insert(theEntity)); TestEntity persisted = tm().transact(() -> tm().load(theEntity.key())); assertThat(persisted.name).isEqualTo("theEntity"); assertThat(persisted.data).isEqualTo("foo"); @@ -221,7 +221,7 @@ public class TransactionManagerTest { @TestTemplate void maybeLoad_succeeds() { assertEntityNotExist(theEntity); - tm().transact(() -> tm().saveNew(theEntity)); + tm().transact(() -> tm().insert(theEntity)); TestEntity persisted = tm().transact(() -> tm().maybeLoad(theEntity.key()).get()); assertThat(persisted.name).isEqualTo("theEntity"); assertThat(persisted.data).isEqualTo("foo"); @@ -235,7 +235,7 @@ public class TransactionManagerTest { @TestTemplate void delete_succeeds() { - tm().transact(() -> tm().saveNew(theEntity)); + tm().transact(() -> tm().insert(theEntity)); assertEntityExists(theEntity); fakeClock.advanceOneMilli(); tm().transact(() -> tm().delete(theEntity.key())); @@ -252,7 +252,7 @@ public class TransactionManagerTest { @TestTemplate void delete_succeedsForEntitySet() { assertAllEntitiesNotExist(moreEntities); - tm().transact(() -> tm().saveAllNew(moreEntities)); + tm().transact(() -> tm().insertAll(moreEntities)); Set> keys = moreEntities.stream().map(TestEntity::key).collect(toImmutableSet()); assertAllEntitiesExist(moreEntities); @@ -264,7 +264,7 @@ public class TransactionManagerTest { @TestTemplate void delete_ignoreNonExistentEntity() { assertAllEntitiesNotExist(moreEntities); - tm().transact(() -> tm().saveAllNew(moreEntities)); + tm().transact(() -> tm().insertAll(moreEntities)); List> keys = moreEntities.stream().map(TestEntity::key).collect(toImmutableList()); assertAllEntitiesExist(moreEntities); @@ -279,7 +279,7 @@ public class TransactionManagerTest { @TestTemplate void load_multi() { assertAllEntitiesNotExist(moreEntities); - tm().transact(() -> tm().saveAllNew(moreEntities)); + tm().transact(() -> tm().insertAll(moreEntities)); List> keys = moreEntities.stream().map(TestEntity::key).collect(toImmutableList()); assertThat(tm().transact(() -> tm().load(keys))) @@ -289,7 +289,7 @@ public class TransactionManagerTest { @TestTemplate void load_multiWithDuplicateKeys() { assertAllEntitiesNotExist(moreEntities); - tm().transact(() -> tm().saveAllNew(moreEntities)); + tm().transact(() -> tm().insertAll(moreEntities)); ImmutableList> keys = moreEntities.stream().map(TestEntity::key).collect(toImmutableList()); ImmutableList> doubleKeys = @@ -301,7 +301,7 @@ public class TransactionManagerTest { @TestTemplate void load_multiMissingKeys() { assertAllEntitiesNotExist(moreEntities); - tm().transact(() -> tm().saveAllNew(moreEntities)); + tm().transact(() -> tm().insertAll(moreEntities)); List> keys = Stream.concat(moreEntities.stream(), Stream.of(new TestEntity("dark", "matter"))) .map(TestEntity::key) @@ -311,11 +311,11 @@ public class TransactionManagerTest { } private static void assertEntityExists(TestEntity entity) { - assertThat(tm().transact(() -> tm().checkExists(entity))).isTrue(); + assertThat(tm().transact(() -> tm().exists(entity))).isTrue(); } private static void assertEntityNotExist(TestEntity entity) { - assertThat(tm().transact(() -> tm().checkExists(entity))).isFalse(); + assertThat(tm().transact(() -> tm().exists(entity))).isFalse(); } private static void assertAllEntitiesExist(ImmutableList entities) { diff --git a/core/src/test/java/google/registry/persistence/transaction/TransactionTest.java b/core/src/test/java/google/registry/persistence/transaction/TransactionTest.java index 70004d27f..84d0f5719 100644 --- a/core/src/test/java/google/registry/persistence/transaction/TransactionTest.java +++ b/core/src/test/java/google/registry/persistence/transaction/TransactionTest.java @@ -66,7 +66,7 @@ class TransactionTest { txn = new Transaction.Builder().addDelete(barEntity.key()).build(); txn.writeToDatastore(); - assertThat(ofyTm().checkExists(barEntity.key())).isEqualTo(false); + assertThat(ofyTm().exists(barEntity.key())).isEqualTo(false); } @Test @@ -83,7 +83,7 @@ class TransactionTest { .transact( () -> { assertThat(ofyTm().load(fooEntity.key())).isEqualTo(fooEntity); - assertThat(ofyTm().checkExists(barEntity.key())).isEqualTo(false); + assertThat(ofyTm().exists(barEntity.key())).isEqualTo(false); }); } @@ -107,8 +107,8 @@ class TransactionTest { jpaTm() .transact( () -> { - jpaTm().saveNew(fooEntity); - jpaTm().saveNew(barEntity); + jpaTm().insert(fooEntity); + jpaTm().insert(barEntity); }); TransactionEntity txnEnt = jpaTm().transact(() -> jpaTm().load(VKey.createSql(TransactionEntity.class, 1L))); @@ -123,8 +123,7 @@ class TransactionTest { // Verify that no transaction was persisted for the load transaction. assertThat( - jpaTm() - .transact(() -> jpaTm().checkExists(VKey.createSql(TransactionEntity.class, 2L)))) + jpaTm().transact(() -> jpaTm().exists(VKey.createSql(TransactionEntity.class, 2L)))) .isFalse(); } finally { RegistryConfig.overrideCloudSqlReplicateTransactions(false); @@ -136,12 +135,10 @@ class TransactionTest { jpaTm() .transact( () -> { - jpaTm().saveNew(fooEntity); - jpaTm().saveNew(barEntity); + jpaTm().insert(fooEntity); + jpaTm().insert(barEntity); }); - assertThat( - jpaTm() - .transact(() -> jpaTm().checkExists(VKey.createSql(TransactionEntity.class, 1L)))) + assertThat(jpaTm().transact(() -> jpaTm().exists(VKey.createSql(TransactionEntity.class, 1L)))) .isFalse(); } diff --git a/core/src/test/java/google/registry/rde/RdeStagingMapperTest.java b/core/src/test/java/google/registry/rde/RdeStagingMapperTest.java index 605a207ca..ce2098e8c 100644 --- a/core/src/test/java/google/registry/rde/RdeStagingMapperTest.java +++ b/core/src/test/java/google/registry/rde/RdeStagingMapperTest.java @@ -73,7 +73,7 @@ class RdeStagingMapperTest { // Set Registrar states which are required for reporting. tm().transact( () -> - tm().saveNewOrUpdateAll( + tm().putAll( ImmutableList.of( externalMonitoringRegistrar.asBuilder().setState(State.ACTIVE).build(), testRegistrar.asBuilder().setState(State.ACTIVE).build(), diff --git a/core/src/test/java/google/registry/schema/registrar/RegistrarContactTest.java b/core/src/test/java/google/registry/schema/registrar/RegistrarContactTest.java index 6e8d30086..78f6bcb7f 100644 --- a/core/src/test/java/google/registry/schema/registrar/RegistrarContactTest.java +++ b/core/src/test/java/google/registry/schema/registrar/RegistrarContactTest.java @@ -65,7 +65,7 @@ class RegistrarContactTest { @Test void testPersistence_succeeds() { - jpaTm().transact(() -> jpaTm().saveNew(testRegistrarPoc)); + jpaTm().transact(() -> jpaTm().insert(testRegistrarPoc)); RegistrarContact persisted = jpaTm().transact(() -> jpaTm().load(testRegistrarPoc.createVKey())); assertThat(persisted).isEqualTo(testRegistrarPoc); diff --git a/core/src/test/java/google/registry/schema/registrar/RegistrarDaoTest.java b/core/src/test/java/google/registry/schema/registrar/RegistrarDaoTest.java index a04b84728..8084daad5 100644 --- a/core/src/test/java/google/registry/schema/registrar/RegistrarDaoTest.java +++ b/core/src/test/java/google/registry/schema/registrar/RegistrarDaoTest.java @@ -70,14 +70,14 @@ public class RegistrarDaoTest { @Test void saveNew_worksSuccessfully() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(testRegistrar))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(testRegistrar)); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(testRegistrar))).isTrue(); + assertThat(jpaTm().transact(() -> jpaTm().exists(testRegistrar))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(testRegistrar)); + assertThat(jpaTm().transact(() -> jpaTm().exists(testRegistrar))).isTrue(); } @Test void update_worksSuccessfully() { - jpaTm().transact(() -> jpaTm().saveNew(testRegistrar)); + jpaTm().transact(() -> jpaTm().insert(testRegistrar)); Registrar persisted = jpaTm().transact(() -> jpaTm().load(registrarKey)); assertThat(persisted.getRegistrarName()).isEqualTo("registrarName"); jpaTm() @@ -92,7 +92,7 @@ public class RegistrarDaoTest { @Test void update_throwsExceptionWhenEntityDoesNotExist() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(testRegistrar))).isFalse(); + assertThat(jpaTm().transact(() -> jpaTm().exists(testRegistrar))).isFalse(); assertThrows( IllegalArgumentException.class, () -> jpaTm().transact(() -> jpaTm().update(testRegistrar))); @@ -100,8 +100,8 @@ public class RegistrarDaoTest { @Test void load_worksSuccessfully() { - assertThat(jpaTm().transact(() -> jpaTm().checkExists(testRegistrar))).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(testRegistrar)); + assertThat(jpaTm().transact(() -> jpaTm().exists(testRegistrar))).isFalse(); + jpaTm().transact(() -> jpaTm().insert(testRegistrar)); Registrar persisted = jpaTm().transact(() -> jpaTm().load(registrarKey)); assertThat(persisted.getClientId()).isEqualTo("registrarId"); diff --git a/core/src/test/java/google/registry/testing/SqlHelper.java b/core/src/test/java/google/registry/testing/SqlHelper.java index f6a051e9d..a9bfa790b 100644 --- a/core/src/test/java/google/registry/testing/SqlHelper.java +++ b/core/src/test/java/google/registry/testing/SqlHelper.java @@ -62,7 +62,7 @@ public class SqlHelper { public static Registrar saveRegistrar(String clientId) { Registrar registrar = makeRegistrar1().asBuilder().setClientId(clientId).build(); - jpaTm().transact(() -> jpaTm().saveNew(registrar)); + jpaTm().transact(() -> jpaTm().insert(registrar)); return jpaTm().transact(() -> jpaTm().load(registrar.createVKey())); } diff --git a/core/src/test/java/google/registry/tools/CreateRegistrarCommandTest.java b/core/src/test/java/google/registry/tools/CreateRegistrarCommandTest.java index 419f8700d..02d28da0b 100644 --- a/core/src/test/java/google/registry/tools/CreateRegistrarCommandTest.java +++ b/core/src/test/java/google/registry/tools/CreateRegistrarCommandTest.java @@ -120,7 +120,7 @@ class CreateRegistrarCommandTest extends CommandTestCase Optional registrar = Registrar.loadByClientId("clientz"); assertThat(registrar).isPresent(); assertThat(registrar.get().verifyPassword("some_password")).isTrue(); - assertThat(jpaTm().transact(() -> jpaTm().checkExists(registrar.get()))).isTrue(); + assertThat(jpaTm().transact(() -> jpaTm().exists(registrar.get()))).isTrue(); } @Test diff --git a/core/src/test/java/google/registry/tools/UpdateRegistrarCommandTest.java b/core/src/test/java/google/registry/tools/UpdateRegistrarCommandTest.java index e3507f04f..9395404e5 100644 --- a/core/src/test/java/google/registry/tools/UpdateRegistrarCommandTest.java +++ b/core/src/test/java/google/registry/tools/UpdateRegistrarCommandTest.java @@ -47,7 +47,7 @@ class UpdateRegistrarCommandTest extends CommandTestCase @Test void testSuccess_alsoUpdateInCloudSql() throws Exception { assertThat(loadRegistrar("NewRegistrar").verifyPassword("some_password")).isFalse(); - jpaTm().transact(() -> jpaTm().saveNew(loadRegistrar("NewRegistrar"))); + jpaTm().transact(() -> jpaTm().insert(loadRegistrar("NewRegistrar"))); runCommand("--password=some_password", "--force", "NewRegistrar"); assertThat(loadRegistrar("NewRegistrar").verifyPassword("some_password")).isTrue(); assertThat(