74685: Refactor RelationshipMetadataServiceTest to use Builders

dspace-api/src/test/java/org/dspace/builder/ItemBuilder.java

@@ -106,6 +106,11 @@ public class ItemBuilder extends AbstractDSpaceObjectBuilder<Item> {
         return addMetadataValue(item, MetadataSchemaEnum.DC.getName(), "description", "provenance", provenanceData);
     }
 
+    public ItemBuilder withMetadata(final String schema, final String element, final String qualifier,
+        final String value) {
+        return addMetadataValue(item, schema, element, qualifier, value);
+    }
+
     public ItemBuilder makeUnDiscoverable() {
         item.setDiscoverable(false);
         return this;

dspace-api/src/test/java/org/dspace/content/RelationshipMetadataServiceTest.java

@@ -11,14 +11,18 @@ import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 
 import java.sql.SQLException;
 import java.util.List;
 
-import org.apache.logging.log4j.Logger;
-import org.dspace.AbstractUnitTest;
+import org.dspace.AbstractIntegrationTestWithDatabase;
 import org.dspace.authorize.AuthorizeException;
+import org.dspace.builder.CollectionBuilder;
+import org.dspace.builder.CommunityBuilder;
+import org.dspace.builder.EntityTypeBuilder;
+import org.dspace.builder.ItemBuilder;
+import org.dspace.builder.RelationshipBuilder;
+import org.dspace.builder.RelationshipTypeBuilder;
 import org.dspace.content.factory.ContentServiceFactory;
 import org.dspace.content.service.CollectionService;
 import org.dspace.content.service.CommunityService;
@@ -29,17 +33,13 @@ import org.dspace.content.service.ItemService;
 import org.dspace.content.service.RelationshipService;
 import org.dspace.content.service.RelationshipTypeService;
 import org.dspace.content.service.WorkspaceItemService;
-import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-public class RelationshipMetadataServiceTest extends AbstractUnitTest {
-
-    private static final Logger log = org.apache.logging.log4j.LogManager
-        .getLogger(RelationshipMetadataServiceTest.class);
+public class RelationshipMetadataServiceTest extends AbstractIntegrationTestWithDatabase {
 
     protected RelationshipMetadataService relationshipMetadataService = ContentServiceFactory
-                                                                        .getInstance().getRelationshipMetadataService();
+        .getInstance().getRelationshipMetadataService();
     protected RelationshipService relationshipService = ContentServiceFactory.getInstance().getRelationshipService();
     protected RelationshipTypeService relationshipTypeService = ContentServiceFactory.getInstance()
                                                                                      .getRelationshipTypeService();
@@ -53,6 +53,7 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
     Item leftItem;
     Item rightItem;
+    Collection col;
     Relationship relationship;
     RelationshipType isAuthorOfPublicationRelationshipType;
 
@@ -65,61 +66,38 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
      */
     @Before
     @Override
-    public void init() {
-        super.init();
-        try {
-            context.turnOffAuthorisationSystem();
-            Community community = communityService.create(null, context);
+    public void setUp() throws Exception {
+        super.setUp();
+        context.turnOffAuthorisationSystem();
+        Community community = CommunityBuilder.createCommunity(context).build();
 
-            Collection col = collectionService.create(context, community);
-            WorkspaceItem leftIs = workspaceItemService.create(context, col, false);
-            WorkspaceItem rightIs = workspaceItemService.create(context, col, false);
+        col = CollectionBuilder.createCollection(context, community).build();
 
-            leftItem = installItemService.installItem(context, leftIs);
-            rightItem = installItemService.installItem(context, rightIs);
-            context.restoreAuthSystemState();
-        } catch (AuthorizeException ex) {
-            log.error("Authorization Error in init", ex);
-            fail("Authorization Error in init: " + ex.getMessage());
-        } catch (SQLException ex) {
-            log.error("SQL Error in init", ex);
-            fail("SQL Error in init: " + ex.getMessage());
-        }
-    }
-
-    /**
-     * This method will be run after every test as per @After. It will
-     * clean resources initialized by the @Before methods.
-     *
-     * Other methods can be annotated with @After here or in subclasses
-     * but no execution order is guaranteed
-     */
-    @After
-    @Override
-    public void destroy() {
-        context.abort();
-        super.destroy();
+        leftItem = ItemBuilder.createItem(context, col).build();
+        rightItem = ItemBuilder.createItem(context, col).build();
+        context.restoreAuthSystemState();
     }
 
     /**
      * Common function to convert leftItem to a publication item, convert rightItem to an author item,
      * and relating them to each other stored in the relationship field
      */
-    private void initPublicationAuthor() throws SQLException, AuthorizeException {
+    private void initPublicationAuthor() {
         context.turnOffAuthorisationSystem();
-        itemService.addMetadata(context, leftItem, "relationship", "type", null, null, "Publication");
-        itemService.addMetadata(context, rightItem, "relationship", "type", null, null, "Author");
-        itemService.addMetadata(context, rightItem, "person", "familyName", null, null, "familyName");
-        itemService.addMetadata(context, rightItem, "person", "givenName", null, null, "firstName");
-        EntityType publicationEntityType = entityTypeService.create(context, "Publication");
-        EntityType authorEntityType = entityTypeService.create(context, "Author");
-        isAuthorOfPublicationRelationshipType = relationshipTypeService
-                .create(context, publicationEntityType, authorEntityType,
-                        "isAuthorOfPublication", "isPublicationOfAuthor",
-                        null, null, null, null);
+        EntityType publicationEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "Publication").build();
+        EntityType authorEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "Author").build();
+        leftItem = ItemBuilder.createItem(context, col).withRelationshipType("Publication").build();
+        rightItem = ItemBuilder.createItem(context, col).withRelationshipType("Author")
+                               .withPersonIdentifierLastName("familyName")
+                               .withPersonIdentifierFirstName("firstName").build();
+        isAuthorOfPublicationRelationshipType =
+            RelationshipTypeBuilder.createRelationshipTypeBuilder(context, publicationEntityType, authorEntityType,
+                "isAuthorOfPublication", "isPublicationOfAuthor",
+                null, null, null, null).build();
 
-        relationship = relationshipService.create(context, leftItem, rightItem,
-            isAuthorOfPublicationRelationshipType, 0, 0);
+        relationship =
+            RelationshipBuilder.createRelationshipBuilder(context, leftItem, rightItem,
+                isAuthorOfPublicationRelationshipType).build();
         context.restoreAuthSystemState();
     }
 
@@ -128,20 +106,22 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
      * and relating them to each other stored in the relationship field
      */
     private void initPublicationAuthorWithCopyParams(boolean copyToLeft, boolean copyToRight)
-        throws SQLException, AuthorizeException {
+        throws SQLException {
         context.turnOffAuthorisationSystem();
-        itemService.addMetadata(context, leftItem, "relationship", "type", null, null, "Publication");
-        itemService.addMetadata(context, rightItem, "relationship", "type", null, null, "Author");
-        itemService.addMetadata(context, rightItem, "person", "familyName", null, null, "familyName");
-        itemService.addMetadata(context, rightItem, "person", "givenName", null, null, "firstName");
-        EntityType publicationEntityType = entityTypeService.create(context, "Publication");
-        EntityType authorEntityType = entityTypeService.create(context, "Author");
-        RelationshipType isAuthorOfPublication = relationshipTypeService
-            .create(context, publicationEntityType, authorEntityType,
-                    "isAuthorOfPublication", "isPublicationOfAuthor",
-                    null, null, null, null, copyToLeft, copyToRight);
+        EntityType publicationEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "Publication").build();
+        EntityType authorEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "Author").build();
+        leftItem = ItemBuilder.createItem(context, col).withRelationshipType("Publication").build();
+        rightItem = ItemBuilder.createItem(context, col).withRelationshipType("Author")
+                               .withPersonIdentifierLastName("familyName")
+                               .withPersonIdentifierFirstName("firstName").build();
+        RelationshipType isAuthorOfPublication =
+            RelationshipTypeBuilder.createRelationshipTypeBuilder(context, publicationEntityType, authorEntityType,
+                "isAuthorOfPublication", "isPublicationOfAuthor",
+                null, null, null, null)
+                                   .withCopyToLeft(copyToLeft).withCopyToRight(copyToRight).build();
 
-        relationship = relationshipService.create(context, leftItem, rightItem, isAuthorOfPublication, 0, 0);
+        relationship =
+            RelationshipBuilder.createRelationshipBuilder(context, leftItem, rightItem, isAuthorOfPublication).build();
         context.restoreAuthSystemState();
     }
 
@@ -149,25 +129,28 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
      * Common function to convert leftItem to a journal issue item, convert rightItem to a journal volume item,
      * and relating them to each other stored in the relationship field
      */
-    private void initJournalVolumeIssue() throws SQLException, AuthorizeException {
+    private void initJournalVolumeIssue() {
         context.turnOffAuthorisationSystem();
-        itemService.addMetadata(context, leftItem, "relationship", "type", null, null, "JournalIssue");
-        itemService.addMetadata(context, rightItem, "relationship", "type", null, null, "JournalVolume");
-        itemService.addMetadata(context, leftItem, "publicationissue", "issueNumber", null, null, "2");
-        itemService.addMetadata(context, rightItem, "publicationvolume", "volumeNumber", null, null, "30");
-        EntityType journalIssueEntityType = entityTypeService.create(context, "JournalIssue");
-        EntityType publicationVolumeEntityType = entityTypeService.create(context, "JournalVolume");
-        RelationshipType isIssueOfVolume = relationshipTypeService
-                .create(context, journalIssueEntityType, publicationVolumeEntityType,
-                        "isJournalVolumeOfIssue", "isIssueOfJournalVolume",
-                        null, null, null, null);
+        EntityType journalIssueEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "JournalIssue").build();
+        EntityType publicationVolumeEntityType =
+            EntityTypeBuilder.createEntityTypeBuilder(context, "JournalVolume").build();
+        leftItem = ItemBuilder.createItem(context, col).withRelationshipType("JournalIssue")
+                              .withPublicationIssueNumber("2").build();
+        rightItem = ItemBuilder.createItem(context, col).withRelationshipType("JournalVolume")
+                               .withPublicationVolumeNumber("30").build();
+        RelationshipType isIssueOfVolume =
+            RelationshipTypeBuilder
+                .createRelationshipTypeBuilder(context, journalIssueEntityType, publicationVolumeEntityType,
+                    "isJournalVolumeOfIssue", "isIssueOfJournalVolume",
+                    null, null, null, null).build();
 
-        relationship = relationshipService.create(context, leftItem, rightItem, isIssueOfVolume, 0, 0);
+        relationship =
+            RelationshipBuilder.createRelationshipBuilder(context, leftItem, rightItem, isIssueOfVolume).build();
         context.restoreAuthSystemState();
     }
 
     @Test
-    public void testGetAuthorRelationshipMetadata() throws SQLException, AuthorizeException {
+    public void testGetAuthorRelationshipMetadata() {
         initPublicationAuthor();
         //leftItem is the publication
         //verify the dc.contributor.author virtual metadata
@@ -192,7 +175,7 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         assertThat(list.get(1).getValue(), equalTo(String.valueOf(rightItem.getID())));
         assertThat(list.get(1).getMetadataField().getMetadataSchema().getName(),
-                equalTo(MetadataSchemaEnum.RELATION.getName()));
+            equalTo(MetadataSchemaEnum.RELATION.getName()));
         assertThat(list.get(1).getMetadataField().getElement(), equalTo("isAuthorOfPublication"));
         assertThat(list.get(1).getAuthority(), equalTo("virtual::" + relationship.getID()));
     }
@@ -217,7 +200,7 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         //verify there's no relation.isAuthorOfPublication actual metadata
         List<MetadataValue> relationshipMetadataList = itemService
-                .getMetadata(leftItem, MetadataSchemaEnum.RELATION.getName(), "isAuthorOfPublication", null, Item.ANY);
+            .getMetadata(leftItem, MetadataSchemaEnum.RELATION.getName(), "isAuthorOfPublication", null, Item.ANY);
         assertThat(relationshipMetadataList.size(), equalTo(0));
 
         //request the virtual metadata of the publication only
@@ -240,7 +223,7 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         //verify there's no relation.isAuthorOfPublication actual metadata on the publication
         List<MetadataValue> relationshipMetadataList = itemService
-                .getMetadata(leftItem, MetadataSchemaEnum.RELATION.getName(), "isAuthorOfPublication", null, Item.ANY);
+            .getMetadata(leftItem, MetadataSchemaEnum.RELATION.getName(), "isAuthorOfPublication", null, Item.ANY);
         assertThat(relationshipMetadataList.size(), equalTo(0));
     }
 
@@ -263,31 +246,31 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         //verify there's no relation.isAuthorOfPublication actual metadata
         List<MetadataValue> relationshipMetadataList = itemService
-                .getMetadata(leftItem, MetadataSchemaEnum.RELATION.getName(), "isAuthorOfPublication", null, Item.ANY);
+            .getMetadata(leftItem, MetadataSchemaEnum.RELATION.getName(), "isAuthorOfPublication", null, Item.ANY);
         assertThat(relationshipMetadataList.size(), equalTo(0));
     }
 
     @Test
-    public void testGetJournalRelationshipMetadata() throws SQLException, AuthorizeException {
+    public void testGetJournalRelationshipMetadata() {
         initJournalVolumeIssue();
 
         //leftItem is the journal issue item
         //verify the publicationvolume.volumeNumber virtual metadata
         List<MetadataValue> volumeList =
-                itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
+            itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
         assertThat(volumeList.size(), equalTo(1));
         assertThat(volumeList.get(0).getValue(), equalTo("30"));
 
         //rightItem is the journal volume item
         //verify the publicationissue.issueNumber virtual metadata
         List<MetadataValue> issueList =
-                itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
+            itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
         assertThat(issueList.size(), equalTo(1));
         assertThat(issueList.get(0).getValue(), equalTo("2"));
 
         //request the virtual metadata of the journal issue
         List<RelationshipMetadataValue> issueRelList =
-                relationshipMetadataService.getRelationshipMetadata(leftItem, true);
+            relationshipMetadataService.getRelationshipMetadata(leftItem, true);
         assertThat(issueRelList.size(), equalTo(2));
         assertThat(issueRelList.get(0).getValue(), equalTo("30"));
         assertThat(issueRelList.get(0).getMetadataField().getMetadataSchema().getName(), equalTo("publicationvolume"));
@@ -297,13 +280,13 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         assertThat(issueRelList.get(1).getValue(), equalTo(String.valueOf(rightItem.getID())));
         assertThat(issueRelList.get(1).getMetadataField().getMetadataSchema().getName(),
-                equalTo(MetadataSchemaEnum.RELATION.getName()));
+            equalTo(MetadataSchemaEnum.RELATION.getName()));
         assertThat(issueRelList.get(1).getMetadataField().getElement(), equalTo("isJournalVolumeOfIssue"));
         assertThat(issueRelList.get(1).getAuthority(), equalTo("virtual::" + relationship.getID()));
 
         //request the virtual metadata of the journal volume
         List<RelationshipMetadataValue> volumeRelList =
-                relationshipMetadataService.getRelationshipMetadata(rightItem, true);
+            relationshipMetadataService.getRelationshipMetadata(rightItem, true);
         assertThat(volumeRelList.size(), equalTo(2));
         assertThat(volumeRelList.get(0).getValue(), equalTo("2"));
         assertThat(volumeRelList.get(0).getMetadataField().getMetadataSchema().getName(), equalTo("publicationissue"));
@@ -313,7 +296,7 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         assertThat(volumeRelList.get(1).getValue(), equalTo(String.valueOf(leftItem.getID())));
         assertThat(volumeRelList.get(1).getMetadataField().getMetadataSchema().getName(),
-                equalTo(MetadataSchemaEnum.RELATION.getName()));
+            equalTo(MetadataSchemaEnum.RELATION.getName()));
         assertThat(volumeRelList.get(1).getMetadataField().getElement(), equalTo("isIssueOfJournalVolume"));
         assertThat(volumeRelList.get(1).getAuthority(), equalTo("virtual::" + relationship.getID()));
     }
@@ -328,13 +311,13 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         //verify the left item's publicationvolume.volumeNumber actual metadata
         List<MetadataValue> volumeList =
-                itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
+            itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
         assertThat(volumeList.size(), equalTo(1));
         assertThat(volumeList.get(0).getValue(), equalTo("30"));
 
         //verify the right item doesn't contain the actual metadata
         List<MetadataValue> issueList =
-                itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
+            itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
         assertThat(issueList.size(), equalTo(0));
     }
 
@@ -348,12 +331,12 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         //verify the left item doesn't contain the publicationvolume.volumeNumber actual metadata
         List<MetadataValue> volumeList =
-                itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
+            itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
         assertThat(volumeList.size(), equalTo(0));
 
         //verify the right item's publicationissue.issueNumber actual metadata
         List<MetadataValue> issueList =
-                itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
+            itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
         assertThat(issueList.size(), equalTo(1));
         assertThat(issueList.get(0).getValue(), equalTo("2"));
     }
@@ -369,13 +352,13 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
 
         //verify the left item's publicationvolume.volumeNumber actual metadata
         List<MetadataValue> volumeList =
-                itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
+            itemService.getMetadata(leftItem, "publicationvolume", "volumeNumber", null, Item.ANY);
         assertThat(volumeList.size(), equalTo(1));
         assertThat(volumeList.get(0).getValue(), equalTo("30"));
 
         //verify the right item's publicationissue.issueNumber actual metadata
         List<MetadataValue> issueList =
-                itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
+            itemService.getMetadata(rightItem, "publicationissue", "issueNumber", null, Item.ANY);
         assertThat(issueList.size(), equalTo(1));
         assertThat(issueList.get(0).getValue(), equalTo("2"));
     }
@@ -458,20 +441,15 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
         assertThat(relationshipService.findNextRightPlaceByRightItem(context, rightItem), equalTo(1));
 
         context.turnOffAuthorisationSystem();
-        Community community = communityService.create(null, context);
+        Community community = CommunityBuilder.createCommunity(context).build();
 
-        Collection col = collectionService.create(context, community);
-        WorkspaceItem is = workspaceItemService.create(context, col, false);
-        Item secondItem = installItemService.installItem(context, is);
-        itemService.addMetadata(context, secondItem, "relationship", "type", null, null, "Publication");
-        relationshipService.create(context, secondItem, rightItem,
-                                   isAuthorOfPublicationRelationshipType, 0, 0);
+        Collection col = CollectionBuilder.createCollection(context, community).build();
+        Item secondItem = ItemBuilder.createItem(context, col).withRelationshipType("Publication").build();
+        RelationshipBuilder.createRelationshipBuilder(context, secondItem, rightItem,
+            isAuthorOfPublicationRelationshipType).build();
         context.restoreAuthSystemState();
 
         assertThat(relationshipService.findNextRightPlaceByRightItem(context, rightItem), equalTo(2));
-
-
-
     }
 
     @Test
@@ -482,16 +460,15 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
         assertThat(relationshipService.findNextLeftPlaceByLeftItem(context, leftItem), equalTo(1));
 
         context.turnOffAuthorisationSystem();
-        Community community = communityService.create(null, context);
+        Community community = CommunityBuilder.createCommunity(context).build();
+        Collection col = CollectionBuilder.createCollection(context, community).build();
 
-        Collection col = collectionService.create(context, community);
-        WorkspaceItem is = workspaceItemService.create(context, col, false);
-        Item secondAuthor = installItemService.installItem(context, is);
-        itemService.addMetadata(context, secondAuthor, "relationship", "type", null, null, "Author");
-        itemService.addMetadata(context, secondAuthor, "person", "familyName", null, null, "familyName");
-        itemService.addMetadata(context, secondAuthor, "person", "givenName", null, null, "firstName");
-        relationshipService.create(context, leftItem, secondAuthor,
-                                   isAuthorOfPublicationRelationshipType, 0, 0);
+        Item secondAuthor = ItemBuilder.createItem(context, col).withRelationshipType("Author")
+                                       .withPersonIdentifierFirstName("firstName")
+                                       .withPersonIdentifierLastName("familyName").build();
+
+        RelationshipBuilder.createRelationshipBuilder(context, leftItem, secondAuthor,
+            isAuthorOfPublicationRelationshipType).build();
         context.restoreAuthSystemState();
 
         assertThat(relationshipService.findNextLeftPlaceByLeftItem(context, leftItem), equalTo(2));
@@ -504,51 +481,46 @@ public class RelationshipMetadataServiceTest extends AbstractUnitTest {
         // Journal, JournalVolume, JournalIssue, Publication items, related to each other using the relationship types
         // isJournalOfVolume, isJournalVolumeOfIssue, isJournalIssueOfPublication.
         context.turnOffAuthorisationSystem();
-        EntityType publicationEntityType = entityTypeService.create(context, "Publication");
-        EntityType journalIssueEntityType = entityTypeService.create(context, "JournalIssue");
-        EntityType journalVolumeEntityType = entityTypeService.create(context, "JournalVolume");
-        EntityType journalEntityType = entityTypeService.create(context, "Journal");
-        RelationshipType isJournalVolumeOfIssueRelationshipType = relationshipTypeService
-            .create(context, journalIssueEntityType, journalVolumeEntityType,
-                "isIssueOfJournalVolume", "isJournalVolumeOfIssue",
-                null, null, null, null);
-        RelationshipType isJournalVolumeOfJournalRelationshipType = relationshipTypeService
-            .create(context, journalVolumeEntityType, journalEntityType,
-                "isJournalOfVolume", "isVolumeOfJournal",
-                null, null, null, null);
-        RelationshipType isJournalIssueOfPublicationRelationshipType = relationshipTypeService
-            .create(context, publicationEntityType, journalIssueEntityType,
-                "isJournalIssueOfPublication", "isPublicationOfJournalIssue",
-                null, null, null, null);
+        EntityType publicationEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "Publication").build();
+        EntityType journalIssueEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "JournalIssue").build();
+        EntityType journalVolumeEntityType =
+            EntityTypeBuilder.createEntityTypeBuilder(context, "JournalVolume").build();
+        EntityType journalEntityType = EntityTypeBuilder.createEntityTypeBuilder(context, "Journal").build();
+        RelationshipType isJournalVolumeOfIssueRelationshipType =
+            RelationshipTypeBuilder.createRelationshipTypeBuilder(context, journalIssueEntityType,
+                journalVolumeEntityType, "isIssueOfJournalVolume", "isJournalVolumeOfIssue", null, null, null, null)
+                                   .build();
+        RelationshipType isJournalVolumeOfJournalRelationshipType =
+            RelationshipTypeBuilder.createRelationshipTypeBuilder(context, journalVolumeEntityType,
+                journalEntityType, "isJournalOfVolume", "isVolumeOfJournal", null, null, null, null)
+                                   .build();
+        RelationshipType isJournalIssueOfPublicationRelationshipType =
+            RelationshipTypeBuilder.createRelationshipTypeBuilder(context, publicationEntityType,
+                journalIssueEntityType, "isJournalIssueOfPublication", "isPublicationOfJournalIssue", null, null, null,
+                null)
+                                   .build();
 
-        Community community = communityService.create(null, context);
-        Collection collection = collectionService.create(context, community);
+        Community community = CommunityBuilder.createCommunity(context).build();
+        Collection collection = CollectionBuilder.createCollection(context, community).build();
 
-        WorkspaceItem iss = workspaceItemService.create(context, collection, false);
-        Item journalIssue = installItemService.installItem(context, iss);
-        itemService.addMetadata(context, journalIssue, "relationship", "type", null, null, "JournalIssue");
-        WorkspaceItem vol = workspaceItemService.create(context, collection, false);
-        Item journalVolume = installItemService.installItem(context, vol);
-        itemService.addMetadata(context, journalVolume, "publicationvolume", "volumeNumber", null, null, "30");
-        itemService.addMetadata(context, journalVolume, "relationship", "type", null, null, "JournalVolume");
-        WorkspaceItem jour = workspaceItemService.create(context, collection, false);
-        Item journal = installItemService.installItem(context, jour);
-        itemService.addMetadata(context, journal, "creativeworkseries", "issn", null, null, "issn journal");
-        itemService.addMetadata(context, journal, "relationship", "type", null, null, "Journal");
-        relationship =
-            relationshipService
-                .create(context, journalIssue, journalVolume, isJournalVolumeOfIssueRelationshipType, 0, 0);
-        relationship =
-            relationshipService.create(context, journalVolume, journal, isJournalVolumeOfJournalRelationshipType, 0, 0);
+        Item journalIssue = ItemBuilder.createItem(context, collection).withRelationshipType("JournalIssue").build();
+        Item journalVolume = ItemBuilder.createItem(context, collection)
+                                        .withPublicationVolumeNumber("30")
+                                        .withRelationshipType("JournalVolume").build();
+        Item journal = ItemBuilder.createItem(context, collection)
+                                  .withMetadata("creativeworkseries", "issn", null, "issn journal")
+                                  .withRelationshipType("Journal").build();
+        RelationshipBuilder.createRelationshipBuilder(context, journalIssue, journalVolume,
+            isJournalVolumeOfIssueRelationshipType).build();
+        RelationshipBuilder.createRelationshipBuilder(context, journalVolume, journal,
+            isJournalVolumeOfJournalRelationshipType).build();
 
-        WorkspaceItem pub = workspaceItemService.create(context, collection, false);
-        Item publication = installItemService.installItem(context, pub);
-        itemService.addMetadata(context, publication, "dc", "title", null, null, "Pub 1");
-        itemService.addMetadata(context, publication, "relationship", "type", null, null, "Publication");
+        Item publication = ItemBuilder.createItem(context, collection)
+                                      .withTitle("Pub 1")
+                                      .withRelationshipType("Publication").build();
 
-        relationship =
-            relationshipService
-                .create(context, publication, journalIssue, isJournalIssueOfPublicationRelationshipType, 0, 0);
+        RelationshipBuilder.createRelationshipBuilder(context, publication, journalIssue,
+            isJournalIssueOfPublicationRelationshipType).build();
         context.restoreAuthSystemState();
 
         // Query for the publication itemService.getMetadata(publication, Item.ANY, Item.ANY, null, Item.ANY, true);