Added: unit tests for GetUserPermittedCollectionsCommand

Author: GPortas

src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetUserPermittedCollectionsCommand.java

@@ -9,6 +9,8 @@
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.RequiredPermissions;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
 
 import java.util.List;
 
@@ -33,6 +35,8 @@
 @RequiredPermissions({})
 public class GetUserPermittedCollectionsCommand extends AbstractCommand<List<Dataverse>> {
 
+    public static final String ANY_PERMISSION = "any";
+
     private final DataverseRequest request;
     private final AuthenticatedUser user;
     private final String permission;
@@ -47,14 +51,13 @@ public GetUserPermittedCollectionsCommand(DataverseRequest request, Authenticate
     @Override
     public List<Dataverse> execute(CommandContext ctxt) throws CommandException {
         if (user == null) {
-            throw new CommandException("User not found.", this);
+            throw new CommandException(BundleUtil.getStringFromBundle("getUserPermittedCollectionsCommand.errors.userNotFound"), this);
         }
         int permissionBit;
         try {
-            permissionBit = permission.equalsIgnoreCase("any") ?
-                    Integer.MAX_VALUE : (1 << Permission.valueOf(permission).ordinal());
+            permissionBit = permission.equalsIgnoreCase(ANY_PERMISSION) ? Integer.MAX_VALUE : (1 << Permission.valueOf(permission).ordinal());
         } catch (IllegalArgumentException e) {
-            throw new CommandException("Permission not valid.", this);
+            throw new InvalidCommandArgumentsException(BundleUtil.getStringFromBundle("getUserPermittedCollectionsCommand.errors.permissionNotValid"), this);
         }
         return ctxt.permissions().findPermittedCollections(request, user, permissionBit);
     }

src/main/java/propertyFiles/Bundle.properties

@@ -3232,3 +3232,7 @@ abstractApiBean.error.internalVersionTimestampIsOutdated=Internal version timest
 
 #RoleAssigneeServiceBean.java
 roleAssigneeServiceBean.error.dataverseRequestCannotBeNull=DataverseRequest cannot be null.
+
+#GetUserPermittedCollectionsCommand.java
+getUserPermittedCollectionsCommand.errors.userNotFound=User not found.
+getUserPermittedCollectionsCommand.errors.permissionNotValid=Permission not valid.

src/test/java/edu/harvard/iq/dataverse/engine/command/impl/GetUserPermittedCollectionsCommandTest.java

@@ -0,0 +1,135 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.PermissionServiceBean;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.engine.command.exception.InvalidCommandArgumentsException;
+import edu.harvard.iq.dataverse.util.BundleUtil;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class GetUserPermittedCollectionsCommandTest {
+
+    private DataverseRequest dataverseRequest;
+    private AuthenticatedUser authenticatedUser;
+    private CommandContext commandContext;
+    private PermissionServiceBean permissionsServiceBean;
+
+    @BeforeEach
+    public void setUp() {
+        dataverseRequest = Mockito.mock(DataverseRequest.class);
+        authenticatedUser = Mockito.mock(AuthenticatedUser.class);
+        commandContext = Mockito.mock(CommandContext.class);
+        permissionsServiceBean = Mockito.mock(PermissionServiceBean.class);
+        Mockito.when(commandContext.permissions()).thenReturn(permissionsServiceBean);
+    }
+
+    @Test
+    public void execute_shouldReturnCollections_whenAnyPermissionIsRequested() throws CommandException {
+        // Arrange
+        Dataverse dv1 = new Dataverse();
+        Dataverse dv2 = new Dataverse();
+        List<Dataverse> expectedDataverses = Arrays.asList(dv1, dv2);
+
+        Mockito.when(permissionsServiceBean.findPermittedCollections(
+                Mockito.any(DataverseRequest.class),
+                Mockito.any(AuthenticatedUser.class),
+                Mockito.eq(Integer.MAX_VALUE)
+        )).thenReturn(expectedDataverses);
+
+        GetUserPermittedCollectionsCommand sut = new GetUserPermittedCollectionsCommand(
+                dataverseRequest,
+                authenticatedUser,
+                GetUserPermittedCollectionsCommand.ANY_PERMISSION
+        );
+
+        // Act
+        List<Dataverse> result = sut.execute(commandContext);
+
+        // Assert
+        assertEquals(expectedDataverses.size(), result.size());
+        assertEquals(expectedDataverses, result);
+        Mockito.verify(permissionsServiceBean).findPermittedCollections(
+                dataverseRequest,
+                authenticatedUser,
+                Integer.MAX_VALUE
+        );
+    }
+
+    @Test
+    public void execute_shouldReturnCollections_whenSpecificPermissionIsRequested() throws CommandException {
+        // Arrange
+        Dataverse dv = new Dataverse();
+        List<Dataverse> expectedDataverses = Collections.singletonList(dv);
+
+        Mockito.when(permissionsServiceBean.findPermittedCollections(
+                Mockito.any(DataverseRequest.class),
+                Mockito.any(AuthenticatedUser.class),
+                Mockito.eq(1 << Permission.AddDataset.ordinal())
+        )).thenReturn(expectedDataverses);
+
+        GetUserPermittedCollectionsCommand sut = new GetUserPermittedCollectionsCommand(
+                dataverseRequest,
+                authenticatedUser,
+                Permission.AddDataset.name()
+        );
+
+        // Act
+        List<Dataverse> result = sut.execute(commandContext);
+
+        // Assert
+        assertEquals(expectedDataverses.size(), result.size());
+        assertEquals(expectedDataverses, result);
+        Mockito.verify(permissionsServiceBean).findPermittedCollections(
+                dataverseRequest,
+                authenticatedUser,
+                1 << Permission.AddDataset.ordinal()
+        );
+    }
+
+    @Test
+    public void execute_shouldThrowException_whenUserIsNotFound() {
+        // Arrange
+        AuthenticatedUser nullUser = null;
+        GetUserPermittedCollectionsCommand sut = new GetUserPermittedCollectionsCommand(
+                dataverseRequest,
+                nullUser,
+                GetUserPermittedCollectionsCommand.ANY_PERMISSION
+        );
+
+        // Act & Assert
+        CommandException exception = assertThrows(CommandException.class, () -> {
+            sut.execute(commandContext);
+        });
+        assertEquals(BundleUtil.getStringFromBundle("getUserPermittedCollectionsCommand.errors.userNotFound"), exception.getMessage());
+    }
+
+    @Test
+    public void execute_shouldThrowException_whenPermissionIsNotValid() {
+        // Arrange
+        String invalidPermission = "invalid_permission_name";
+        GetUserPermittedCollectionsCommand sut = new GetUserPermittedCollectionsCommand(
+                dataverseRequest,
+                authenticatedUser,
+                invalidPermission
+        );
+
+        // Act & Assert
+        InvalidCommandArgumentsException exception = assertThrows(InvalidCommandArgumentsException.class, () -> {
+            sut.execute(commandContext);
+        });
+        assertEquals(BundleUtil.getStringFromBundle("getUserPermittedCollectionsCommand.errors.permissionNotValid"), exception.getMessage());
+    }
+}