From 30e17894d6102776b51ff6c65d1978ce66453131 Mon Sep 17 00:00:00 2001 From: Bruno Roemers Date: Wed, 25 May 2022 13:58:32 +0200 Subject: [PATCH] 91680: Verify that relationship place changes don't affect other relationships --- .../RelationshipServiceImplPlaceTest.java | 565 ++++++++++++++++++ 1 file changed, 565 insertions(+) diff --git a/dspace-api/src/test/java/org/dspace/content/RelationshipServiceImplPlaceTest.java b/dspace-api/src/test/java/org/dspace/content/RelationshipServiceImplPlaceTest.java index 04a93d7712..3e36f77c68 100644 --- a/dspace-api/src/test/java/org/dspace/content/RelationshipServiceImplPlaceTest.java +++ b/dspace-api/src/test/java/org/dspace/content/RelationshipServiceImplPlaceTest.java @@ -80,6 +80,7 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { Item project6; RelationshipType isAuthorOfPublication; + RelationshipType isProjectOfPublication; RelationshipType isProjectOfPerson; EntityType publicationEntityType; @@ -220,6 +221,10 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { .create(context, publicationEntityType, personEntityType, "isAuthorOfPublication", "isPublicationOfAuthor", null, null, null, null); + isProjectOfPublication = relationshipTypeService + .create(context, publicationEntityType, projectEntityType, + "isProjectOfPublication", "isPublicationOfProject", + null, null, null, null); isProjectOfPerson = relationshipTypeService .create(context, personEntityType, projectEntityType, "isProjectOfPerson", "isPersonOfProject", @@ -741,6 +746,52 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { )); } + @Test + public void createUseForPlaceRelationshipWithLeftPlaceInTheMiddleWithMetadataTest_ignoreOtherRels( + ) throws Exception { + context.turnOffAuthorisationSystem(); + + // Add a dc.contributor.author MDV + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 1"); + + // Add two Authors to the same Publication, appending to the end + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + Relationship r2 = relationshipService.create(context, publication1, author2, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + // Add another dc.contributor.author MDV + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 2"); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, author2, project2, isProjectOfPerson, -1, -1); + + // Add another Author @ leftPlace 2. All MDVs & relationships after it should get pushed by one place + Relationship r3 = relationshipService.create(context, publication1, author3, isAuthorOfPublication, 2, -1); + + context.restoreAuthSystemState(); + + // Check relationship order + assertLeftPlace(r1, 1); + assertLeftPlace(r3, 2); + assertLeftPlace(r2, 3); + assertRelationMetadataOrder(publication1, isAuthorOfPublication, List.of(r1, r3, r2)); + assertMetadataOrder(publication1, "dc.contributor.author", List.of( + "MDV 1", + "Author, First", + "Author, Third", + "Author, Second", + "MDV 2" + )); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 0); + assertRightPlace(ur2, 0); + } + @Test public void createUseForPlaceRelationshipWithLeftPlaceAtTheEndWithMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -832,6 +883,39 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(author1, isAuthorOfPublication, List.of(r1, r3, r2)); } + @Test + public void createUseForPlaceRelationshipWithRightPlaceInTheMiddleNoMetadataTest_ignoreOtherRels( + ) throws Exception { + context.turnOffAuthorisationSystem(); + + // Add two Publications to the same Author, appending to the end + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + Relationship r2 = relationshipService.create(context, publication2, author1, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, author1, project2, isProjectOfPerson, -1, -1); + + // Add another Publication @ rightPlace 1. The second relationship should get pushed by one place + Relationship r3 = relationshipService.create(context, publication3, author1, isAuthorOfPublication, -1, 1); + + context.restoreAuthSystemState(); + + // Check relationship order + assertRightPlace(r1, 0); + assertRightPlace(r3, 1); + assertRightPlace(r2, 2); + assertRelationMetadataOrder(author1, isAuthorOfPublication, List.of(r1, r3, r2)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 1); + assertRightPlace(ur2, 0); + } + @Test public void createUseForPlaceRelationshipWithRightPlaceAtTheEndNoMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -910,6 +994,33 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(author1, isProjectOfPerson, List.of(r1, r3, r2)); } + @Test + public void createNonUseForPlaceRelationshipWithLeftPlaceInTheMiddleTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Add two Projects to the same Author, appending to the end + Relationship r1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + Relationship r2 = relationshipService.create(context, author1, project2, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + + // Add another Project @ leftPlace 1. The second relationship should get pushed by one place + Relationship r3 = relationshipService.create(context, author1, project3, isProjectOfPerson, 1, -1); + + context.restoreAuthSystemState(); + + // Check relationship order + assertLeftPlace(r1, 0); + assertLeftPlace(r3, 1); + assertLeftPlace(r2, 2); + assertRelationMetadataOrder(author1, isProjectOfPerson, List.of(r1, r3, r2)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + } + @Test public void createNonUseForPlaceRelationshipWithLeftPlaceAtTheEndTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -988,6 +1099,33 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r1, r3, r2)); } + @Test + public void createNonUseForPlaceRelationshipWithRightPlaceInTheMiddleTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Add two Authors to the same Project, appending to the end + Relationship r1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + Relationship r2 = relationshipService.create(context, author2, project1, isProjectOfPerson, -1, -1); + + // Add another Author @ rightPlace 1. The second relationship should get pushed by one place + Relationship r3 = relationshipService.create(context, author3, project1, isProjectOfPerson, -1, 1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + context.restoreAuthSystemState(); + + // Check relationship order + assertRightPlace(r1, 0); + assertRightPlace(r3, 1); + assertRightPlace(r2, 2); + assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r1, r3, r2)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + } + @Test public void createNonUseForPlaceRelationshipWithRightPlaceAtTheEndTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -1219,6 +1357,42 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(publication1, isAuthorOfPublication, List.of(r2, r1, r3)); } + @Test + public void moveUseForPlaceRelationshipUpToLeftPlaceInTheMiddleWithTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + // Initialize MDVs and Relationships + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 1"); + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + Relationship r2 = relationshipService.create(context, publication1, author2, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, publication1, project2, isProjectOfPublication, -1, -1); + + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 2"); + Relationship r3 = relationshipService.create(context, publication1, author3, isAuthorOfPublication, -1, -1); + + // Move the first Author to leftPlace=3 + relationshipService.move(context, r1, 3, null); + + context.restoreAuthSystemState(); + + // Check relationship order + assertLeftPlace(r2, 1); + assertLeftPlace(r1, 3); + assertLeftPlace(r3, 4); + assertRelationMetadataOrder(publication1, isAuthorOfPublication, List.of(r2, r1, r3)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 1); + assertRightPlace(ur2, 0); + } + @Test public void moveUseForPlaceRelationshipDownToLeftPlaceInTheMiddleWithMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -1242,6 +1416,43 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(publication1, isAuthorOfPublication, List.of(r1, r3, r2)); } + @Test + public void moveUseForPlaceRelationshipDownToLeftPlaceInTheMiddleWithMetadataTest_ignoreOtherRels( + ) throws Exception { + context.turnOffAuthorisationSystem(); + + // Initialize MDVs and Relationships + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 1"); + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + Relationship r2 = relationshipService.create(context, publication1, author2, isAuthorOfPublication, -1, -1); + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 2"); + Relationship r3 = relationshipService.create(context, publication1, author3, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, author2, project2, isProjectOfPerson, -1, -1); + + // Move the last Author to leftPlace=2 + relationshipService.move(context, r3, 2, null); + + context.restoreAuthSystemState(); + + // Check relationship order + assertLeftPlace(r1, 1); + assertLeftPlace(r3, 2); + assertLeftPlace(r2, 3); + assertRelationMetadataOrder(publication1, isAuthorOfPublication, List.of(r1, r3, r2)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 0); + assertRightPlace(ur2, 0); + } + @Test public void moveUseForPlaceRelationshipToLeftPlaceAtTheEndWithMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -1609,6 +1820,47 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r2, r1, r3)); } + @Test + public void moveNonUseForPlaceRelationshipUpToRightPlaceInTheMiddleNoMetadataTest_ignoreOtherRels( + ) throws Exception { + context.turnOffAuthorisationSystem(); + + // Add three Authors to the same Project, appending to the end + Relationship r1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + Relationship r2 = relationshipService.create(context, author2, project1, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, publication2, project1, isProjectOfPublication, -1, -1); + + Relationship r3 = relationshipService.create(context, author3, project1, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur3 = relationshipService.create(context, publication3, project1, isProjectOfPublication, -1, -1); + + // Move the first Author to leftPlace=1 + relationshipService.move(context, r1, null, 1); + + context.restoreAuthSystemState(); + + // Check relationship order + assertRightPlace(r2, 0); + assertRightPlace(r1, 1); + assertRightPlace(r3, 2); + assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r2, r1, r3)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 0); + assertRightPlace(ur2, 1); + assertLeftPlace(ur3, 0); + assertRightPlace(ur3, 2); + } + @Test public void moveNonUseForPlaceRelationshipDownToRightPlaceInTheMiddleNoMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -1630,6 +1882,36 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r1, r3, r2)); } + @Test + public void moveNonUseForPlaceRelationshipDownToRightPlaceInTheMiddleNoMetadataTest_ignoreOtherRels( + ) throws Exception { + context.turnOffAuthorisationSystem(); + + // Add three Authors to the same Project, appending to the end + Relationship r1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + Relationship r2 = relationshipService.create(context, author2, project1, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + Relationship r3 = relationshipService.create(context, author3, project1, isProjectOfPerson, -1, -1); + + // Move the last Author to leftPlace=1 + relationshipService.move(context, r3, null, 1); + + context.restoreAuthSystemState(); + + // Check relationship order + assertRightPlace(r1, 0); + assertRightPlace(r3, 1); + assertRightPlace(r2, 2); + assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r1, r3, r2)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + } + @Test public void moveNonUseForPlaceRelationshipToRightPlaceAtTheEndNoMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -1797,6 +2079,41 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { )); } + @Test + public void deleteUseForPlaceRelationshipFromLeftMiddleWithMetadataNoCopyTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Initialize MDVs and Relationships + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 1"); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + Relationship r2 = relationshipService.create(context, publication1, author2, isAuthorOfPublication, -1, -1); + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 2"); + Relationship r3 = relationshipService.create(context, publication1, author3, isAuthorOfPublication, -1, -1); + + relationshipService.delete(context, r2, false, false); + + context.restoreAuthSystemState(); + + // Check relationship order + assertLeftPlace(r1, 0); + assertLeftPlace(r3, 3); + assertRelationMetadataOrder(publication1, isAuthorOfPublication, Arrays.asList(r1, r3)); + assertMetadataOrder(publication1, "dc.contributor.author", List.of( + "Author, First", + "MDV 1", + "MDV 2", + "Author, Third" + )); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + } + @Test public void deleteUseForPlaceRelationshipFromLeftMiddleWithMetadataCopyTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -1826,6 +2143,55 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { )); } + @Test + public void deleteUseForPlaceRelationshipFromLeftMiddleWithMetadataCopyTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Initialize MDVs and Relationships + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 1"); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, publication1, project2, isProjectOfPublication, -1, -1); + + Relationship r2 = relationshipService.create(context, publication1, author2, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur3 = relationshipService.create(context, author2, project1, isProjectOfPerson, -1, -1); + + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 2"); + Relationship r3 = relationshipService.create(context, publication1, author3, isAuthorOfPublication, -1, -1); + + relationshipService.delete(context, r2, true, false); + + context.restoreAuthSystemState(); + + // Check relationship order + assertLeftPlace(r1, 0); + // NOTE: since R2 has been removed, but copied to left, this place remains at 4 (instead of 3) + assertLeftPlace(r3, 4); + assertRelationMetadataOrder(publication1, isAuthorOfPublication, Arrays.asList(r1, null, r3)); + assertMetadataOrder(publication1, "dc.contributor.author", List.of( + "Author, First", + "MDV 1", + "Author, Second", // this is not longer a relationship + "MDV 2", + "Author, Third" + )); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 1); + assertRightPlace(ur2, 0); + assertLeftPlace(ur3, 0); + assertRightPlace(ur3, 0); + } + @Test public void deleteUseForPlaceRelationshipFromLeftEndWithMetadataNoCopyTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -2042,6 +2408,34 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r1, r3)); } + @Test + public void deleteNonUseForPlaceRelationshipFromRightMiddleNoMetadataTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Add three Authors to the same Project, appending to the end + Relationship r1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + Relationship r2 = relationshipService.create(context, author2, project1, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + Relationship r3 = relationshipService.create(context, author3, project1, isProjectOfPerson, -1, -1); + + // Delete the second Publication + relationshipService.delete(context, r2); + + context.restoreAuthSystemState(); + + // Check relationship order + assertRightPlace(r1, 0); + assertRightPlace(r3, 1); + assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r1, r3)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + } + @Test public void deleteNonUseForPlaceRelationshipFromRightEndNoMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -2258,6 +2652,81 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { )); } + @Test + public void changeLeftItemInUseForPlaceRelationshipInTheMiddleWithMetadataTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Add three Authors to publication1, with regular MDVs in between + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 1"); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + Relationship r2 = relationshipService.create(context, publication1, author2, isAuthorOfPublication, -1, -1); + itemService.addMetadata(context, publication1, dcSchema, contributorElement, authorQualifier, null, "MDV 2"); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, publication1, project3, isProjectOfPublication, -1, -1); + + Relationship r3 = relationshipService.create(context, publication1, author3, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur3 = relationshipService.create(context, publication2, project2, isProjectOfPublication, -1, -1); + + // Add three Authors to publication2, with regular MDVs in between + itemService.addMetadata(context, publication2, dcSchema, contributorElement, authorQualifier, null, "MDV 3"); + Relationship r4 = relationshipService.create(context, publication2, author4, isAuthorOfPublication, -1, -1); + Relationship r5 = relationshipService.create(context, publication2, author5, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur4 = relationshipService.create(context, publication2, project1, isProjectOfPublication, -1, -1); + + itemService.addMetadata(context, publication2, dcSchema, contributorElement, authorQualifier, null, "MDV 4"); + Relationship r6 = relationshipService.create(context, publication2, author6, isAuthorOfPublication, -1, -1); + + // Move r2 to publication 2 + relationshipService.move(context, r2, publication2, null); + + context.restoreAuthSystemState(); + + // Check relationship order for publication1 + assertLeftPlace(r1, 0); // should both move down as the first Relationship was removed + assertLeftPlace(r3, 3); + assertRelationMetadataOrder(publication1, isAuthorOfPublication, List.of(r1, r3)); + assertMetadataOrder(publication1, "dc.contributor.author", List.of( + "Author, First", + "MDV 1", + "MDV 2", + "Author, Third" + )); + + // Check relationship order for publication2 + assertLeftPlace(r4, 1); // previous Relationships should stay where they were + assertLeftPlace(r5, 2); + assertLeftPlace(r6, 4); + assertLeftPlace(r2, 5); // moved Relationship should be appended to the end + assertRelationMetadataOrder(publication2, isAuthorOfPublication, List.of(r4, r5, r6, r2)); + assertMetadataOrder(publication2, "dc.contributor.author", List.of( + "MDV 3", + "Author, Fourth", + "Author, Fifth", + "MDV 4", + "Author, Sixth", + "Author, Second" + )); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 1); + assertRightPlace(ur2, 0); + assertLeftPlace(ur3, 0); + assertRightPlace(ur3, 0); + assertLeftPlace(ur4, 1); + assertRightPlace(ur4, 1); + } + @Test public void changeLeftItemInUseForPlaceRelationshipAtTheEndWithMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -2372,6 +2841,51 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(author2, isAuthorOfPublication, List.of(r4, r5, r6, r2)); } + @Test + public void changeRightItemInUseForPlaceRelationshipInTheMiddleNoMetadataTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Add three Publications to author1, appending to the end + Relationship r1 = relationshipService.create(context, publication1, author1, isAuthorOfPublication, -1, -1); + Relationship r2 = relationshipService.create(context, publication2, author1, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + + Relationship r3 = relationshipService.create(context, publication3, author1, isAuthorOfPublication, -1, -1); + + // Add three Publications to author2, appending to the end + Relationship r4 = relationshipService.create(context, publication4, author2, isAuthorOfPublication, -1, -1); + Relationship r5 = relationshipService.create(context, publication5, author2, isAuthorOfPublication, -1, -1); + Relationship r6 = relationshipService.create(context, publication6, author2, isAuthorOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, author2, project1, isProjectOfPerson, -1, -1); + + // Move r2 to author2 + relationshipService.move(context, r2, null, author2); + + context.restoreAuthSystemState(); + + // Check relationship order for author1 + assertRightPlace(r1, 0); + assertRightPlace(r3, 1); // should move down as the first Relationship was removed + assertRelationMetadataOrder(author1, isAuthorOfPublication, List.of(r1, r3)); + + // Check relationship order for author2 + assertRightPlace(r4, 0); // previous Relationships should stay where they were + assertRightPlace(r5, 1); + assertRightPlace(r6, 2); + assertRightPlace(r2, 3); // moved Relationship should be appended to the end + assertRelationMetadataOrder(author2, isAuthorOfPublication, List.of(r4, r5, r6, r2)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 0); + assertRightPlace(ur2, 1); + } + @Test public void changeRightItemInUseForPlaceRelationshipAtTheEndNoMetadataTest() throws Exception { context.turnOffAuthorisationSystem(); @@ -2564,6 +3078,57 @@ public class RelationshipServiceImplPlaceTest extends AbstractUnitTest { assertRelationMetadataOrder(project2, isProjectOfPerson, List.of(r4, r5, r6, r2)); } + @Test + public void changeRightItemInNonUseForPlaceRelationshipInTheMiddleTest_ignoreOtherRels() throws Exception { + context.turnOffAuthorisationSystem(); + + // Add three Authors to project1, appending to the end + Relationship r1 = relationshipService.create(context, author1, project1, isProjectOfPerson, -1, -1); + Relationship r2 = relationshipService.create(context, author2, project1, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur1 = relationshipService.create(context, publication1, project1, isProjectOfPublication, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur2 = relationshipService.create(context, publication2, project1, isProjectOfPublication, -1, -1); + + Relationship r3 = relationshipService.create(context, author3, project1, isProjectOfPerson, -1, -1); + + // Add three Authors to project2, appending to the end + Relationship r4 = relationshipService.create(context, author4, project2, isProjectOfPerson, -1, -1); + Relationship r5 = relationshipService.create(context, author5, project2, isProjectOfPerson, -1, -1); + + // NOTE: unrelated relationship => should not be affected + Relationship ur3 = relationshipService.create(context, author5, project3, isProjectOfPerson, -1, -1); + + Relationship r6 = relationshipService.create(context, author6, project2, isProjectOfPerson, -1, -1); + + // Move r2 to project2 + relationshipService.move(context, r2, null, project2); + + context.restoreAuthSystemState(); + + // Check relationship order for project1 + assertRightPlace(r1, 0); + assertRightPlace(r3, 1); // should move down as the first Relationship was removed + assertRelationMetadataOrder(project1, isProjectOfPerson, List.of(r1, r3)); + + // Check relationship order for project2 + assertRightPlace(r4, 0); // previous Relationships should stay where they were + assertRightPlace(r5, 1); + assertRightPlace(r6, 2); + assertRightPlace(r2, 3); // moved Relationship should be appended to the end + assertRelationMetadataOrder(project2, isProjectOfPerson, List.of(r4, r5, r6, r2)); + + // check unaffected relationships + assertLeftPlace(ur1, 0); + assertRightPlace(ur1, 0); + assertLeftPlace(ur2, 0); + assertRightPlace(ur2, 1); + assertLeftPlace(ur3, 1); + assertRightPlace(ur3, 0); + } + @Test public void changeRightItemInNonUseForPlaceRelationshipAtTheEndTest() throws Exception { context.turnOffAuthorisationSystem();