diff --git a/e2e-test/java/org/alfresco/rest/comments/AddCommentsFullTests.java b/e2e-test/java/org/alfresco/rest/comments/AddCommentsFullTests.java new file mode 100644 index 000000000..23a46bacd --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/comments/AddCommentsFullTests.java @@ -0,0 +1,162 @@ +package org.alfresco.rest.comments; + +import org.alfresco.dataprep.CMISUtil.DocumentType; +import org.alfresco.rest.RestTest; +import org.alfresco.rest.core.JsonBodyGenerator; +import org.alfresco.rest.core.RestRequest; +import org.alfresco.rest.model.RestCommentModel; +import org.alfresco.rest.model.RestCommentModelsCollection; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.data.DataUser; +import org.alfresco.utility.model.FileModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.apache.commons.lang.RandomStringUtils; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +/** + * Created by Andrei Rusu + */ +public class AddCommentsFullTests extends RestTest +{ + private UserModel adminUserModel; + private FileModel document; + private SiteModel siteModel; + private DataUser.ListUserWithRoles usersWithRoles; + private String comment = "This is a new comment"; + private String comment2 = "This is the second comment"; + private RestCommentModelsCollection comments; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUserModel = dataUser.getAdminUser(); + restClient.authenticateUser(adminUserModel); + siteModel = dataSite.usingUser(adminUserModel).createPrivateRandomSite(); + usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); + } + + @TestRail(section={TestGroup.REST_API, TestGroup.FULL, TestGroup.COMMENTS}, executionType= ExecutionType.REGRESSION, + description= "Using Manager user verify that you can provide a large string for one comment") + @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.FULL }) + public void addLongCommentsWithManagerAndCheckThatCommentIsReturned() throws Exception + { + document = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(DocumentType.TEXT_PLAIN); + String longString = RandomStringUtils.randomAlphanumeric(10000); + String longString1 = RandomStringUtils.randomAlphanumeric(90000); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager)) + .withCoreAPI().usingResource(document).addComments(longString, longString1); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + comments = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(document).getNodeComments(); + restClient.assertStatusCodeIs(HttpStatus.OK); + comments.assertThat().entriesListContains("content", longString); + comments.assertThat().entriesListContains("content", longString1); + comments.assertThat().paginationField("totalItems").is("2"); + comments.assertThat().paginationField("count").is("2"); + } + + @TestRail(section={TestGroup.REST_API, TestGroup.FULL, TestGroup.COMMENTS}, executionType= ExecutionType.REGRESSION, + description= "Using Manager user verify that you can provide a short string for one comment") + @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.FULL }) + public void addShortCommentsWithManagerAndCheckThatCommentIsReturned() throws Exception + { + document = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(DocumentType.TEXT_PLAIN); + String shortString = RandomStringUtils.randomAlphanumeric(2); + String shortString1 = RandomStringUtils.randomAlphanumeric(1); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager)) + .withCoreAPI().usingResource(document).addComments(shortString, shortString1); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + comments = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(document).getNodeComments(); + restClient.assertStatusCodeIs(HttpStatus.OK); + comments.assertThat().entriesListContains("content", shortString); + comments.assertThat().entriesListContains("content", shortString1); + comments.assertThat().paginationField("totalItems").is("2"); + comments.assertThat().paginationField("count").is("2"); + } + + @TestRail(section={TestGroup.REST_API, TestGroup.FULL, TestGroup.COMMENTS}, executionType= ExecutionType.REGRESSION, + description= "Using Collaborator user verify that you can provide a string with special characters for one comment") + @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.FULL }) + public void addCommentsWithSpecialCharsWithCollaboratorCheckCommentIsReturned() throws Exception + { + document = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(DocumentType.TEXT_PLAIN); + String specialCharsString = "!@#$%^&*()_+♂µΓyádo«√<╡┌6£"; + String shortString = RandomStringUtils.randomAlphanumeric(2); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)) + .withCoreAPI().usingResource(document).addComments(specialCharsString, shortString); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + comments = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(document).getNodeComments(); + restClient.assertStatusCodeIs(HttpStatus.OK); + comments.assertThat().entriesListContains("content", specialCharsString); + comments.assertThat().entriesListContains("content", shortString); + comments.assertThat().paginationField("totalItems").is("2"); + comments.assertThat().paginationField("count").is("2"); + } + + @TestRail(section={TestGroup.REST_API, TestGroup.FULL, TestGroup.COMMENTS}, executionType= ExecutionType.REGRESSION, + description= "Using Manager user verify that you can not provide an empty string for one comment") + @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.FULL }) + public void addEmptyStringCommentsWithManagerCheckCommentIsReturned() throws Exception + { + document = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(DocumentType.TEXT_PLAIN); + String emptyString = ""; + String spaceString = " "; + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager)) + .withCoreAPI().usingResource(document).addComments(emptyString, spaceString); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary(RestErrorModel.NON_NULL_COMMENT); + } + + @TestRail(section={TestGroup.REST_API, TestGroup.FULL, TestGroup.COMMENTS}, executionType= ExecutionType.REGRESSION, + description= "Using Collaborator user verify that you can provide several comments in one request") + @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.FULL }) + public void addSeveralCommentsWithCollaboratorCheckCommentsAreReturned() throws Exception + { + document = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(DocumentType.TEXT_PLAIN); + String charString = RandomStringUtils.randomAlphanumeric(10); + String charString1 = RandomStringUtils.randomAlphanumeric(10); + String charString2 = RandomStringUtils.randomAlphanumeric(10); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)) + .withCoreAPI().usingResource(document).addComments(comment, comment2, charString, charString1, charString2); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + comments = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(document).getNodeComments(); + restClient.assertStatusCodeIs(HttpStatus.OK); + comments.assertThat().entriesListContains("content", comment); + comments.assertThat().paginationField("totalItems").is("5"); + comments.assertThat().paginationField("count").is("5"); + } + + @TestRail(section={TestGroup.REST_API, TestGroup.FULL, TestGroup.COMMENTS}, executionType= ExecutionType.REGRESSION, + description= "Provide invalid request body parameter and check default error model schema") + @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.FULL }) + public void invalidRequestBodyParameterCheckErrorModelSchema() throws Exception + { + document = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(DocumentType.TEXT_PLAIN); + + restClient.authenticateUser(adminUserModel).withCoreAPI(); + String postBody = JsonBodyGenerator.keyValueJson("content2", comment); + RestRequest request = RestRequest.requestWithBody(HttpMethod.POST, postBody, "nodes/{nodeId}/comments", document.getNodeRef()); + restClient.processModel(RestCommentModel.class, request); + + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST); + restClient.assertLastError().getErrorKey().contains("Unrecognized field \"content2\""); + restClient.assertLastError().containsSummary("Unrecognized field \"content2\""); + restClient.assertLastError().getDescriptionURL().contains("https://api-explorer.alfresco.com"); + restClient.assertLastError().getStackTrace().contains("For security reasons the stack trace is no longer displayed, but the property is kept for previous versions"); + } +} diff --git a/e2e-test/java/org/alfresco/rest/comments/AddCommentsSanityTests.java b/e2e-test/java/org/alfresco/rest/comments/AddCommentsSanityTests.java index da6615e43..cc6838009 100644 --- a/e2e-test/java/org/alfresco/rest/comments/AddCommentsSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/comments/AddCommentsSanityTests.java @@ -115,10 +115,9 @@ public class AddCommentsSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.COMMENTS }, executionType = ExecutionType.SANITY, description = "Verify unauthenticated user gets status code 401 on post multiple comments call") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) - @Bug(id="MNT-16904") public void unauthenticatedUserIsNotAbleToAddComments() throws JsonToModelConversionException, Exception { - restClient.authenticateUser(new UserModel("random user", "random password")) + restClient.noAuthentication() .withCoreAPI().usingResource(document).addComments(comment1, comment2); restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED); } diff --git a/e2e-test/java/org/alfresco/rest/comments/GetCommentsSanityTests.java b/e2e-test/java/org/alfresco/rest/comments/GetCommentsSanityTests.java index cdec30ed3..4385ea6d8 100644 --- a/e2e-test/java/org/alfresco/rest/comments/GetCommentsSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/comments/GetCommentsSanityTests.java @@ -40,7 +40,7 @@ public class GetCommentsSanityTests extends RestTest usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, description= "Verify Admin user gets comments with Rest API and status code is 200") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) public void adminIsAbleToRetrieveComments() throws JsonToModelConversionException, Exception @@ -51,7 +51,7 @@ public class GetCommentsSanityTests extends RestTest comments.assertThat().entriesListContains("content", content); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, description= "Verify Manager user gets comments created by admin user with Rest API and status code is 200") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) public void managerIsAbleToRetrieveComments() throws JsonToModelConversionException, Exception @@ -62,7 +62,7 @@ public class GetCommentsSanityTests extends RestTest comments.assertThat().entriesListContains("content", content); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, description= "Verify Contributor user gets comments created by admin user with Rest API and status code is 200") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) public void contributorIsAbleToRetrieveComments() throws JsonToModelConversionException, Exception @@ -73,7 +73,7 @@ public class GetCommentsSanityTests extends RestTest comments.assertThat().entriesListContains("content", content); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, description= "Verify Collaborator user gets comments created by admin user with Rest API and status code is 200") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) public void collaboratorIsAbleToRetrieveComments() throws JsonToModelConversionException, Exception @@ -84,7 +84,7 @@ public class GetCommentsSanityTests extends RestTest comments.assertThat().entriesListContains("content", content); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, description= "Verify Consumer user gets comments created by admin user with Rest API and status code is 200") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) public void consumerIsAbleToRetrieveComments() throws JsonToModelConversionException, Exception @@ -95,8 +95,9 @@ public class GetCommentsSanityTests extends RestTest comments.assertThat().entriesListContains("content", content); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, - description= "Verify Manager user gets status code 401 if authentication call fails") + + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, + description= "Verify Manager user gets status code 401 if authentication call fails") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) @Bug(id="MNT-16904") public void managerIsNotAbleToRetrieveCommentIfAuthenticationFails() throws JsonToModelConversionException, Exception @@ -107,7 +108,7 @@ public class GetCommentsSanityTests extends RestTest restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastExceptionContains(HttpStatus.UNAUTHORIZED.toString()); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, description= "Verify Manager user gets comments created by another user and status code is 200") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) public void managerIsAbleToRetrieveCommentsCreatedByAnotherUser() throws JsonToModelConversionException, Exception @@ -124,7 +125,7 @@ public class GetCommentsSanityTests extends RestTest .and().entriesListContains("content", content); } - @TestRail(section={TestGroup.REST_API, TestGroup.SANITY}, executionType= ExecutionType.SANITY, + @TestRail(section={TestGroup.REST_API, TestGroup.COMMENTS}, executionType= ExecutionType.SANITY, description= "Verify admin user gets comments created by another user and status code is 200") @Test(groups = { TestGroup.REST_API, TestGroup.COMMENTS, TestGroup.SANITY }) public void adminIsAbleToRetrieveCommentsCreatedByAnotherUser() throws JsonToModelConversionException, Exception diff --git a/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesCoreTests.java b/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesCoreTests.java index 04dcbb590..2c09b2b53 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesCoreTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesCoreTests.java @@ -38,8 +38,7 @@ public class AddFavoritesCoreTests extends RestTest public void dataPreparation() throws Exception { adminUserModel = dataUser.getAdminUser(); - siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); - siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); diff --git a/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesSanityTests.java b/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesSanityTests.java index 2947d05c1..91fb77a7e 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/AddFavoritesSanityTests.java @@ -26,9 +26,7 @@ public class AddFavoritesSanityTests extends RestTest public void dataPreparation() throws Exception { adminUserModel = dataUser.getAdminUser(); - siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); - siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); - + siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); } diff --git a/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteCoreTests.java b/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteCoreTests.java new file mode 100644 index 000000000..ac965bcf9 --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteCoreTests.java @@ -0,0 +1,174 @@ +package org.alfresco.rest.favorites; + +import org.alfresco.dataprep.CMISUtil.DocumentType; +import org.alfresco.rest.RestTest; +import org.alfresco.rest.exception.JsonToModelConversionException; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.data.DataUser.ListUserWithRoles; +import org.alfresco.utility.model.FileModel; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +public class DeleteFavoriteCoreTests extends RestTest +{ + private UserModel adminUserModel; + private SiteModel siteModel; + private ListUserWithRoles usersWithRoles; + private FileModel fileModel; + private FolderModel folderModel; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUserModel = dataUser.getAdminUser(); + + siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + + fileModel = dataContent.usingSite(siteModel).createContent(DocumentType.TEXT_PLAIN); + folderModel = dataContent.usingSite(siteModel).usingUser(adminUserModel).createFolder(); + + usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, + UserRole.SiteContributor); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that status code is 404 if PersonID is incorrect - favorite file.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE}) + public void deleteFavoriteIfPersonIdNotExists() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel); + + restClient.withCoreAPI().usingUser(new UserModel("inexistent", "inexistent")) + .deleteFileFromFavorites(fileModel).assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "inexistent")); + } + + @Bug(id="ACE-2413") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that status code is 404 if PersonID is empty - favorite file.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE}) + public void deleteFavoriteIfPersonIdIsEmpty() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel); + + restClient.withCoreAPI().usingUser(new UserModel ("", "")) + .deleteFileFromFavorites(fileModel).assertStatusCodeIs(HttpStatus.BAD_REQUEST); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that status code is 404 if FavoriteID is incorrect - favorite file.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE}) + public void deleteFavoriteFileIfFavoriteIdIsIncorrect() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(fileModel); + + fileModel.setNodeRef("wrongFavoriteId"); + restClient.withCoreAPI().usingAuthUser() + .deleteFileFromFavorites(fileModel).assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "wrongFavoriteId")); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that status code is 404 if FavoriteID is incorrect - favorite file.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE}) + public void deleteFavoriteFileIfFavoriteIdNotExists() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(fileModel); + FileModel inexistentDocument = new FileModel(); + inexistentDocument.setNodeRef("inexistent"); + + restClient.withCoreAPI().usingAuthUser() + .deleteFileFromFavorites(inexistentDocument).assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "inexistent")); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that status code is 404 if FavoriteID is incorrect - favorite site.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE}) + public void deleteFavoriteIfFavoriteIdNotExists() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + siteModel.setGuid("wrongFavoriteId"); + + restClient.withCoreAPI().usingAuthUser() + .deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "wrongFavoriteId")); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that status code is 404 if FavoriteID is incorrect - favorite folder.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE}) + public void deleteFavoriteFolderIfFavoriteIdNotExists() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel); + + folderModel.setNodeRef("wrongFavoriteId"); + restClient.withCoreAPI().usingAuthUser() + .deleteFolderFromFavorites(folderModel).assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "wrongFavoriteId")); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify user removes a site from favorites using '-me-' in place of personId with Rest API and response is successful (204)") + public void deleteFavoriteSiteWithSuccessUsingMeAsPersonId() throws Exception + { + siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + + restClient.withCoreAPI().usingMe().deleteSiteFromFavorites(siteModel); + restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT); + } + + @Bug(id="ACE-5588") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE }) + public void collaboratorIsNotAbleToDeleteFavoriteOfAnotherUser() throws JsonToModelConversionException, Exception + { + UserModel siteCollaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator); + restClient.authenticateUser(siteCollaborator).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id="ACE-5588") + @TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify admin user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE }) + public void adminIsNotAbleToDeleteFavoriteOfAnotherUser() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)) + .withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.authenticateUser(adminUserModel) + .withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + + +} diff --git a/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteFullTests.java b/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteFullTests.java new file mode 100644 index 000000000..854fd3451 --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteFullTests.java @@ -0,0 +1,246 @@ +package org.alfresco.rest.favorites; + +import org.alfresco.dataprep.CMISUtil.DocumentType; +import org.alfresco.rest.RestTest; +import org.alfresco.rest.exception.JsonToModelConversionException; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.data.DataUser.ListUserWithRoles; +import org.alfresco.utility.model.FileModel; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +public class DeleteFavoriteFullTests extends RestTest +{ + private UserModel adminUserModel, tenantUser, adminTenantUser; + private SiteModel siteModel; + private ListUserWithRoles usersWithRoles; + private FileModel fileModel; + private FolderModel folderModel; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUserModel = dataUser.getAdminUser(); + + siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + + fileModel = dataContent.usingSite(siteModel).createContent(DocumentType.TEXT_PLAIN); + folderModel = dataContent.usingSite(siteModel).usingUser(adminUserModel).createFolder(); + + usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, + UserRole.SiteContributor); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify admin deletes files from favorites with Rest API and status code is (204)") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void adminIsAbleToDeleteFavoriteFile() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(fileModel); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + restClient.withCoreAPI().usingAuthUser().deleteFileFromFavorites(fileModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", fileModel.getNodeRefWithoutVersion()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify admin deletes folder from favorites with Rest API and status code is (204)") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void adminIsAbleToDeleteFavoriteFolder() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + restClient.withCoreAPI().usingAuthUser().deleteFolderFromFavorites(folderModel) + .assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", fileModel.getNodeRefWithoutVersion()); + } + + @Bug(id="ACE-5588") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify consumer user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void consumerIsNotAbleToDeleteFavoriteOfAnotherUser() throws JsonToModelConversionException, Exception + { + UserModel siteConsumer = usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer); + restClient.authenticateUser(siteConsumer).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id="ACE-5588") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify contributor user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void contributorIsNotAbleToDeleteFavoriteOfAnotherUser() throws JsonToModelConversionException, Exception + { + UserModel siteContributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor); + restClient.authenticateUser(siteContributor).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id="ACE-5588") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify contributor user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void adminIsNotAbleToDeleteFavoriteOfAnotherUser() throws JsonToModelConversionException, Exception + { + UserModel user = dataUser.createRandomTestUser(); + restClient.authenticateUser(user).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.authenticateUser(adminUserModel).withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify admin is not able to deletes files from favorites that were already deleted with Rest API and status code is (404)") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void adminIsNotAbleToDeletesADeletedFavoriteFile() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(fileModel); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + restClient.withCoreAPI().usingAuthUser().deleteFileFromFavorites(fileModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", fileModel.getNodeRefWithoutVersion()); + + restClient.withCoreAPI().usingAuthUser().deleteFileFromFavorites(fileModel) + .assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, + adminUserModel.getUsername(), fileModel.getNodeRef())); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify user can't delete favorites using an invalid network ID.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsNotAbleToDeleteFavoriteSiteWithInvalidNetworkID() throws Exception + { + UserModel networkUserModel = dataUser.createRandomTestUser(); + restClient.authenticateUser(networkUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + networkUserModel.setDomain("invalidNetwork"); + + restClient.withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError() + .containsSummary(RestErrorModel.AUTHENTICATION_FAILED) + .containsErrorKey(RestErrorModel.API_DEFAULT_ERRORKEY) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify contributor user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void adminDeletesFavoriteForNotFavouriteFile() throws JsonToModelConversionException, Exception + { + fileModel = dataContent.usingSite(siteModel).createContent(DocumentType.TEXT_PLAIN); + + restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser() + .deleteFileFromFavorites(fileModel) + .assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, + adminUserModel.getUsername(), fileModel.getNodeRef())) + .containsErrorKey(RestErrorModel.RELATIONSHIP_NOT_FOUND_ERRORKEY) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @Bug(id="MNT-16904") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.NETWORKS }, executionType = ExecutionType.REGRESSION, + description = "Verify tenant user is not able to delete favorites using an invalid network ID") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES,TestGroup.NETWORKS, TestGroup.FULL }) + public void tenantIsNotAbleToDeleteFavoriteSiteWithInvalidNetworkID() throws JsonToModelConversionException, Exception + { + adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser); + tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + siteModel = dataSite.usingUser(tenantUser).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(tenantUser).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + tenantUser.setDomain("invalidNetwork"); + + restClient.withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError() + .containsSummary(RestErrorModel.AUTHENTICATION_FAILED) + .containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.NETWORKS }, executionType = ExecutionType.REGRESSION, + description = "Verify tenant user deletes favorites site and status code is (204)") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES,TestGroup.NETWORKS, TestGroup.FULL }) + public void tenantDeleteFavoriteSiteValidNetwork() throws JsonToModelConversionException, Exception + { + adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser); + tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + siteModel = dataSite.usingUser(tenantUser).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(tenantUser).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + tenantUser.setDomain(tenantUser.getDomain()); + + restClient.withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuidWithoutVersion()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.NETWORKS }, executionType = ExecutionType.REGRESSION, + description = "Verify tenant user deletes favorites site created by admin tenant - same network and status code is (204)") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES,TestGroup.NETWORKS, TestGroup.FULL }) + public void tenantUserIsAbleToDeleteFavoriteSiteAddedByAdminSameNetwork() throws JsonToModelConversionException, Exception + { + adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser); + tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + siteModel = dataSite.usingUser(adminTenantUser).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(adminTenantUser).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + tenantUser.setDomain(adminTenantUser.getDomain()); + + restClient.withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuidWithoutVersion()); + } + +} diff --git a/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoritesSanityTests.java b/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteSanityTests.java similarity index 79% rename from e2e-test/java/org/alfresco/rest/favorites/DeleteFavoritesSanityTests.java rename to e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteSanityTests.java index 2503d7c7a..2d399c106 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoritesSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteSanityTests.java @@ -1,146 +1,171 @@ -package org.alfresco.rest.favorites; - -import org.alfresco.rest.RestTest; -import org.alfresco.rest.exception.JsonToModelConversionException; -import org.alfresco.rest.model.RestErrorModel; -import org.alfresco.utility.constants.UserRole; -import org.alfresco.utility.data.DataUser.ListUserWithRoles; -import org.alfresco.utility.model.SiteModel; -import org.alfresco.utility.model.TestGroup; -import org.alfresco.utility.model.UserModel; -import org.alfresco.utility.report.Bug; -import org.alfresco.utility.testrail.ExecutionType; -import org.alfresco.utility.testrail.annotation.TestRail; -import org.springframework.http.HttpStatus; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; - -public class DeleteFavoritesSanityTests extends RestTest -{ - private UserModel adminUserModel; - private SiteModel siteModel; - private ListUserWithRoles usersWithRoles; - - @BeforeClass(alwaysRun = true) - public void dataPreparation() throws Exception - { - adminUserModel = dataUser.getAdminUser(); - - siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); - siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); - - usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, - UserRole.SiteContributor); - } - - @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify Admin user deletes site from favorites with Rest API and status code is 204") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void adminIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception - { - restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); - - restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); - restClient.withCoreAPI().usingAuthUser().getFavorites().assertThat().entriesListDoesNotContain("targetGuid", siteModel.getGuid()); - } - - @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify Manager user deletes site from favorites with Rest API and status code is 204") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void managerIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception - { - UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); - restClient.authenticateUser(siteManager).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); - - restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); - restClient.withCoreAPI().usingAuthUser().getFavorites().assertThat().entriesListDoesNotContain("targetGuid", siteModel.getGuid()); - } - - @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify Collaborator user deletes site from favorites with Rest API and status code is 204") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void collaboratorIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception - { - UserModel siteCollaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator); - restClient.authenticateUser(siteCollaborator).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); - - restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); - restClient.withCoreAPI().usingAuthUser().getFavorites().assertThat().entriesListDoesNotContain("targetGuid", siteModel.getGuid()); - } - - @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify Contributor user deletes site from favorites with Rest API and status code is 204") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void contributorIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception - { - UserModel siteContributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor); - restClient.authenticateUser(siteContributor).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); - - restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); - restClient.withCoreAPI().usingAuthUser().getFavorites().assertThat().entriesListDoesNotContain("targetGuid", siteModel.getGuid()); - } - - @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify Consumer user delets site from favorites with Rest API and status code is 204") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void consumerIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception - { - UserModel siteConsumer = usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer); - restClient.authenticateUser(siteConsumer).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); - - restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); - restClient.withCoreAPI().usingAuthUser().getFavorites().assertThat().entriesListDoesNotContain("targetGuid", siteModel.getGuid()); - } - - @Bug(id="MNT-16557") - @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify user doesn't have permission to delete favorites of another user with Rest API and status code is 404") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void userIsNotAbleToDeleteFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception - { - UserModel siteCollaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator); - restClient.authenticateUser(siteCollaborator).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); - restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).withCoreAPI() - .usingAuthUser().deleteSiteFromFavorites(siteModel) - .assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); - } - - @Bug(id="MNT-16557") - @TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify user doesn't have permission to delete favorites of admin user with Rest API and status code is 404") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void userIsNotAbleToDeleteFavoritesOfAdminUser() throws JsonToModelConversionException, Exception - { - restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); - - restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)) - .withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel) - .assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); - } - - @Bug(id="MNT-16557") - @TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify admin user doesn't have permission to delete favorites of another user with Rest API and status code is 404") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void adminIsNotAbleToDeleteFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception - { - restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)) - .withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); - - restClient.authenticateUser(adminUserModel) - .withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel) - .assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); - } - - @Bug(id = "MNT-16904") - @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, - description = "Verify user gets status code 401 if authentication call fails") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - public void userIsNotAbleToDeleteFavoritesIfAuthenticationFails() throws JsonToModelConversionException, Exception - { - UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); - siteManager.setPassword("wrongPassword"); - restClient.authenticateUser(siteManager).withCoreAPI().usingAuthUser() - .deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.UNAUTHORIZED); - } -} +package org.alfresco.rest.favorites; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.exception.JsonToModelConversionException; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.data.DataUser.ListUserWithRoles; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +public class DeleteFavoriteSanityTests extends RestTest +{ + private UserModel adminUserModel; + private SiteModel siteModel; + private ListUserWithRoles usersWithRoles; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUserModel = dataUser.getAdminUser(); + + siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + + usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, + UserRole.SiteContributor); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify Admin user deletes site from favorites with Rest API and status code is 204") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void adminIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception + { + restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + + restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites().assertThat().entriesListDoesNotContain("targetGuid", siteModel.getGuid()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify Manager user deletes site from favorites with Rest API and status code is 204") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void managerIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception + { + UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); + restClient.authenticateUser(siteManager).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuid()) + .and().entriesListDoesNotContain("id", siteModel.getId()) + .and().entriesListDoesNotContain("description", siteModel.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel.getTitle()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify Collaborator user deletes site from favorites with Rest API and status code is 204") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void collaboratorIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception + { + UserModel siteCollaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator); + restClient.authenticateUser(siteCollaborator).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuid()) + .and().entriesListDoesNotContain("id", siteModel.getId()) + .and().entriesListDoesNotContain("description", siteModel.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel.getTitle()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify Contributor user deletes site from favorites with Rest API and status code is 204") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void contributorIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception + { + UserModel siteContributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor); + restClient.authenticateUser(siteContributor).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuid()) + .and().entriesListDoesNotContain("id", siteModel.getId()) + .and().entriesListDoesNotContain("description", siteModel.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel.getTitle()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify Consumer user delets site from favorites with Rest API and status code is 204") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void consumerIsAbleToDeleteFavorites() throws JsonToModelConversionException, Exception + { + UserModel siteConsumer = usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer); + restClient.authenticateUser(siteConsumer).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.NO_CONTENT); + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuid()) + .and().entriesListDoesNotContain("id", siteModel.getId()) + .and().entriesListDoesNotContain("description", siteModel.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel.getTitle()); + } + + @Bug(id="MNT-16557") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void userIsNotAbleToDeleteFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception + { + UserModel siteCollaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator); + restClient.authenticateUser(siteCollaborator).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).withCoreAPI() + .usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id="MNT-16557") + @TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify user doesn't have permission to delete favorites of admin user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void userIsNotAbleToDeleteFavoritesOfAdminUser() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)) + .withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id="MNT-16557") + @TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify admin user doesn't have permission to delete favorites of another user with Rest API and status code is 404") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void adminIsNotAbleToDeleteFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)) + .withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.authenticateUser(adminUserModel) + .withCoreAPI().usingAuthUser().deleteSiteFromFavorites(siteModel) + .assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id = "MNT-16904") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, + description = "Verify user gets status code 401 if authentication call fails") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) + public void userIsNotAbleToDeleteFavoritesIfAuthenticationFails() throws JsonToModelConversionException, Exception + { + UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); + siteManager.setPassword("wrongPassword"); + restClient.authenticateUser(siteManager).withCoreAPI().usingAuthUser() + .deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.UNAUTHORIZED); + } +} diff --git a/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteCoreTests.java b/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteCoreTests.java index c3b3e0668..e078d9bda 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteCoreTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteCoreTests.java @@ -13,6 +13,7 @@ import org.alfresco.utility.model.FolderModel; import org.alfresco.utility.model.SiteModel; import org.alfresco.utility.model.TestGroup; import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; import org.alfresco.utility.testrail.ExecutionType; import org.alfresco.utility.testrail.annotation.TestRail; import org.springframework.http.HttpStatus; @@ -36,9 +37,6 @@ public class GetFavoriteCoreTests extends RestTest { fileModel = dataContent.usingUser(adminUserModel).usingResource(folderModel) .createContent(DocumentType.TEXT_PLAIN); - siteModel.setGuid( - restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); - usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); } @@ -60,6 +58,22 @@ public class GetFavoriteCoreTests extends RestTest { .containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY); } + @Bug(id = "ACE-2413") + @TestRail(section = { TestGroup.REST_API, + TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify get favorite site when person id is empty") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE }) + public void getFavoriteSiteWithEmptyUserId() throws JsonToModelConversionException, Exception { + + restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + UserModel someUser = new UserModel("", DataUser.PASSWORD); + + restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(someUser).getFavorite(siteModel.getGuid()); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, someUser.getUsername())) + .statusCodeIs(HttpStatus.BAD_REQUEST); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify get favorite site when favorite id does't exist") @@ -103,4 +117,16 @@ public class GetFavoriteCoreTests extends RestTest { restClient.assertStatusCodeIs(HttpStatus.OK); favoriteSite.assertThat().field("targetGuid").equals(siteModel.getGuid()); } + + @TestRail(section = { TestGroup.REST_API, + TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify get favorite site for -me-") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE }) + public void getFavoriteFileUsingMe() throws Exception + { + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).withCoreAPI().usingAuthUser().addFileToFavorites(fileModel); + + RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingMe().getFavorite(fileModel.getNodeRefWithoutVersion()); + restClient.assertStatusCodeIs(HttpStatus.OK); + favoriteFile.assertThat().field("targetGuid").equals(fileModel.getNodeRef()); + } } \ No newline at end of file diff --git a/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteFullTests.java b/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteFullTests.java index 05323bb89..6d9d2d43c 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteFullTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteFullTests.java @@ -6,13 +6,13 @@ import org.alfresco.rest.exception.JsonToModelConversionException; import org.alfresco.rest.model.RestErrorModel; import org.alfresco.rest.model.RestPersonFavoritesModel; import org.alfresco.utility.constants.UserRole; -import org.alfresco.utility.data.DataUser; import org.alfresco.utility.data.DataUser.ListUserWithRoles; import org.alfresco.utility.model.FileModel; import org.alfresco.utility.model.FolderModel; import org.alfresco.utility.model.SiteModel; import org.alfresco.utility.model.TestGroup; import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; import org.alfresco.utility.testrail.ExecutionType; import org.alfresco.utility.testrail.annotation.TestRail; import org.springframework.http.HttpStatus; @@ -20,7 +20,7 @@ import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; public class GetFavoriteFullTests extends RestTest { - private UserModel adminUserModel, networkUserModel; + private UserModel adminUserModel; private SiteModel siteModel; private FolderModel folderModel; private FileModel fileModel; @@ -29,7 +29,6 @@ public class GetFavoriteFullTests extends RestTest { @BeforeClass(alwaysRun = true) public void dataPreparation() throws Exception { - networkUserModel = dataUser.createRandomTestUser(); adminUserModel = dataUser.getAdminUser(); restClient.authenticateUser(adminUserModel); @@ -39,29 +38,94 @@ public class GetFavoriteFullTests extends RestTest { fileModel = dataContent.usingUser(adminUserModel).usingResource(folderModel) .createContent(DocumentType.TEXT_PLAIN); - siteModel.setGuid( - restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); - usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); } + + @Bug(id = "MNT-16904") @TestRail(section = { TestGroup.REST_API, - TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify get favorite site when using invalid network id") - @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) - public void getFavoriteSiteWhenNetworkIdIsInvalid() throws JsonToModelConversionException, Exception + TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify the get favorite request for invalid network id") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL, TestGroup.NETWORKS }) + public void getFavoriteSiteWithInvalidNetworkId() throws Exception { - networkUserModel.setDomain("invalidNetwork"); - restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); - UserModel someUser = new UserModel("invalidUser", DataUser.PASSWORD); - - restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(someUser).getFavorite(siteModel.getGuid()); - restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError() - .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, someUser.getUsername())) - .statusCodeIs(HttpStatus.NOT_FOUND) - .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) - .stackTraceIs(RestErrorModel.STACKTRACE) - .containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY); + UserModel adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel); + restClient.usingTenant().createTenant(adminTenantUser); + UserModel tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + + siteModel = dataSite.usingUser(tenantUser).createPublicRandomSite(); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + tenantUser.setDomain("invalidNetwork"); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid()); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError() + .containsSummary(RestErrorModel.AUTHENTICATION_FAILED); } + + @TestRail(section = { TestGroup.REST_API, + TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify the get favorite request with tenant user") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL, TestGroup.NETWORKS }) + public void getFavoriteSiteWithTenantUser() throws Exception + { + UserModel adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser); + UserModel tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + + siteModel = dataSite.usingUser(tenantUser).createPublicRandomSite(); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + + restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid()); + restClient.assertStatusCodeIs(HttpStatus.OK); + } + + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify Admin user gets favorite site with Rest API and validate details") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void verifyRequestforGetFavoriteSite() throws JsonToModelConversionException, Exception + { + restClient.authenticateUser(adminUserModel); + restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel); + + RestPersonFavoritesModel favoriteSite = restClient.withCoreAPI().usingUser(adminUserModel).getFavorite(siteModel.getGuid()); + restClient.assertStatusCodeIs(HttpStatus.OK); + favoriteSite.assertThat().field("targetGuid").equals(siteModel.getGuid()); + favoriteSite.getTarget().getSite() + .assertThat().field("guid").equals(siteModel.getGuid()); + } + + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify Admin user gets favorite site with properties filter") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void verifyRequestforGetFavoriteSiteWithProperties() throws JsonToModelConversionException, Exception + { + UserModel manager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); + restClient.authenticateUser(manager); + restClient.withCoreAPI().usingUser(manager).addSiteToFavorites(siteModel); + + RestPersonFavoritesModel favoriteSite = restClient.authenticateUser(manager).withParams("properties=targetGuid") + .withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid()); + restClient.assertStatusCodeIs(HttpStatus.OK); + favoriteSite.assertThat().field("targetGuid").equals(siteModel.getGuid()); + favoriteSite.assertThat().fieldsCount().is(1); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify Admin user gets favorite site with inccorect properties filter") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void verifyRequestforGetFavoriteSiteWithInccorectProperties() throws JsonToModelConversionException, Exception + { + UserModel collaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator); + restClient.authenticateUser(collaborator); + restClient.withCoreAPI().usingUser(collaborator).addSiteToFavorites(siteModel); + + RestPersonFavoritesModel favoriteSite = restClient.authenticateUser(collaborator).withParams("properties=tas") + .withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion()); + restClient.assertStatusCodeIs(HttpStatus.OK); + favoriteSite.assertThat().fieldsCount().is(0); + } } \ No newline at end of file diff --git a/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSanityTests.java b/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSanityTests.java index 688ce6ff5..62613ef1f 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSanityTests.java @@ -5,8 +5,6 @@ import org.alfresco.rest.RestTest; import org.alfresco.rest.exception.JsonToModelConversionException; import org.alfresco.rest.model.RestErrorModel; import org.alfresco.rest.model.RestPersonFavoritesModel; -import org.alfresco.rest.model.RestPersonFavoritesModelsCollection; -import org.alfresco.rest.model.RestSiteModelsCollection; import org.alfresco.utility.constants.UserRole; import org.alfresco.utility.data.DataUser.ListUserWithRoles; import org.alfresco.utility.model.FileModel; @@ -38,9 +36,6 @@ public class GetFavoriteSanityTests extends RestTest folderModel = dataContent.usingUser(adminUserModel).usingSite(siteModel).createFolder(); fileModel = dataContent.usingUser(adminUserModel).usingResource(folderModel).createContent(DocumentType.TEXT_PLAIN); - - siteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(siteModel).getSite().getGuid()); - usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); } @@ -285,14 +280,14 @@ public class GetFavoriteSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, description = "Verify user gets status code 401 if authentication call fails") @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - @Bug(id = "MNT-16904") + @Bug(id = "MNT-16904", description = "fails only on environment with tenants") public void userIsNotAbleToRetrieveFavoritesIfAuthenticationFails() throws JsonToModelConversionException, Exception { UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); siteManager.setPassword("wrongPassword"); restClient.authenticateUser(siteManager).withCoreAPI() .usingUser(siteManager).getFavorite(siteModel.getGuid()); - restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastExceptionContains(HttpStatus.UNAUTHORIZED.toString()); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED); } - } diff --git a/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesCoreTests.java b/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesCoreTests.java index c75947d8c..94c4175f9 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesCoreTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesCoreTests.java @@ -37,10 +37,6 @@ public class GetFavoritesCoreTests extends RestTest secondFolderModel = dataContent.usingUser(adminUserModel).usingSite(firstSiteModel).createFolder(); firstFileModel = dataContent.usingUser(adminUserModel).usingResource(firstFolderModel).createContent(CMISUtil.DocumentType.TEXT_PLAIN); secondFileModel = dataContent.usingUser(adminUserModel).usingResource(firstFolderModel).createContent(CMISUtil.DocumentType.TEXT_PLAIN); - - firstSiteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(firstSiteModel).getSite().getGuid()); - secondSiteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(secondSiteModel).getSite().getGuid()); - usersWithRoles = dataUser.addUsersWithRolesToSite(firstSiteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); } diff --git a/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesFullTests.java b/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesFullTests.java new file mode 100644 index 000000000..382cbed41 --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesFullTests.java @@ -0,0 +1,230 @@ +package org.alfresco.rest.favorites; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.exception.JsonToModelConversionException; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestPersonFavoritesModel; +import org.alfresco.rest.model.RestPersonFavoritesModelsCollection; +import org.alfresco.rest.model.RestSiteModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +public class GetFavoritesFullTests extends RestTest +{ + private UserModel adminUserModel; + private UserModel secondUserModel; + private SiteModel firstSiteModel, secondSiteModel, thirdSiteModel; + private RestPersonFavoritesModelsCollection userFavorites; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUserModel = dataUser.getAdminUser(); + secondUserModel = dataUser.createRandomTestUser(); + restClient.authenticateUser(adminUserModel); + firstSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); + secondSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); + thirdSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); + + firstSiteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(firstSiteModel).getSite().getGuid()); + secondSiteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(secondSiteModel).getSite().getGuid()); + thirdSiteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(thirdSiteModel).getSite().getGuid()); + + restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel); + restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel); + + restClient.authenticateUser(secondUserModel); + restClient.withCoreAPI().usingUser(secondUserModel).addSiteToFavorites(firstSiteModel); + restClient.withCoreAPI().usingUser(secondUserModel).addSiteToFavorites(secondSiteModel); + restClient.withCoreAPI().usingUser(secondUserModel).addSiteToFavorites(thirdSiteModel); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites specifying -me- string in place of for request") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsAbleToGetFavoritesWhenUsingMeAsUsername() throws Exception + { + userFavorites = restClient.authenticateUser(secondUserModel).withCoreAPI().usingMe().getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.OK); + userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid()).and().entriesListContains("targetGuid", secondSiteModel.getGuid()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites using empty for where parameter for request") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsAbleToGetFavoritesWhenUsingEmptyWhereParameter() throws Exception + { + userFavorites = restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().where().getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(String.format(RestErrorModel.INVALID_ARGUMENT, "WHERE query")); + } + + @TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that for invalid maxItems parameter status code returned is 400.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void checkInvalidMaxItemsStatusCode() throws Exception + { + restClient.authenticateUser(adminUserModel).withParams("maxItems=AB").withCoreAPI().usingUser(adminUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary("Invalid paging parameter"); + } + + @TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify that for invalid skipCount parameter status code returned is 400.") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void checkInvalidSkipCountStatusCode() throws Exception + { + restClient.authenticateUser(adminUserModel).withParams("skipCount=AB").withCoreAPI().usingUser(adminUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary("Invalid paging parameter"); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites when using invalid network id") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void getFavoritesWhenNetworkIdIsInvalid() throws Exception + { + UserModel networkUserModel = dataUser.createRandomTestUser(); + networkUserModel.setDomain("invalidNetwork"); + restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(networkUserModel).where().targetSiteExist().getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, networkUserModel.getUsername())); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites using special chars in where parameter for request") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsNotAbleToGetFavoritesWhenUsingSpecialCharsInWhereParameter() throws Exception + { + userFavorites = restClient.withCoreAPI().usingAuthUser().where().invalidWhereParameter("~!%40%23%24%25%5E%26*()_%2B%5B%5D%7B%7D%7C%5C%3B%27%3A%22%2C.%2F%3C%3E").getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(String.format(RestErrorModel.INVALID_ARGUMENT, "WHERE query")) + .containsErrorKey(RestErrorModel.INVALID_QUERY_ERRORKEY) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites using AND instead of OR in where parameter for request") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsNotAbleToGetFavoritesWhenUsingANDInWhereParameter() throws Exception + { + userFavorites = restClient.withCoreAPI().usingAuthUser().where().targetFolderExist().invalidWhereParameter("AND").targetFileExist().getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(String.format(RestErrorModel.INVALID_ARGUMENT, "WHERE query")); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites using wrong name instead of EXISTS in where parameter for request") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsNotAbleToGetFavoritesWhenUsingWrongWhereParameter() throws Exception + { + userFavorites = restClient.withCoreAPI().usingAuthUser().where().invalidWhereParameter("EXIST((target/site))").targetFileExist().getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(String.format(RestErrorModel.INVALID_ARGUMENT, "WHERE query")); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites except the first one for request") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsAbleToGetFavoritesExceptTheFirstOne() throws Exception + { + userFavorites = restClient.authenticateUser(secondUserModel).withParams("skipCount=1").withCoreAPI().usingUser(secondUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.OK); + + userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid()) + .and().entriesListContains("targetGuid", secondSiteModel.getGuid()) + .and().entriesListDoesNotContain("targetGuid", thirdSiteModel.getGuid()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get first two favorites sites") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsAbleToGetFirstTwoFavorites() throws Exception + { + userFavorites = restClient.authenticateUser(secondUserModel).withParams("maxItems=2").withCoreAPI().usingUser(secondUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.OK); + + userFavorites.assertThat().entriesListContains("targetGuid", thirdSiteModel.getGuid()) + .and().entriesListContains("targetGuid", secondSiteModel.getGuid()) + .and().entriesListDoesNotContain("targetGuid", firstSiteModel.getGuid()) + .getPagination().assertThat().field("maxItems").is("2") + .and().field("hasMoreItems").is("true") + .and().field("count").is("2"); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify get favorites sites when using empty values for skipCount and maxItems") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsAbleToGetFavoritesWhenSkipCountAndMaxItemsAreEmpty() throws Exception + { + restClient.authenticateUser(secondUserModel).withParams("skipCount= ").withCoreAPI().usingUser(secondUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary(String.format(RestErrorModel.INVALID_SKIPCOUNT, " ")); + + restClient.authenticateUser(secondUserModel).withParams("maxItems= ").withCoreAPI().usingUser(secondUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary(String.format(RestErrorModel.INVALID_MAXITEMS, " ")); + } + + @Bug(id = "MNT-16904") + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify the get favorites request when network id is invalid") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL, TestGroup.NETWORKS}) + public void getFavoriteSitesWhenNetworkIdIsInvalid() throws JsonToModelConversionException, Exception + { + UserModel adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel); + restClient.usingTenant().createTenant(adminTenantUser); + UserModel tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel); + + tenantUser.setDomain("invalidNetwork"); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify the get favorites request for a high value for skipCount parameter") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsAbleToGetFavoritesWithHighSkipCount() throws Exception + { + userFavorites = restClient.authenticateUser(secondUserModel).withParams("skipCount=999999999").withCoreAPI().usingUser(secondUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.OK); + + userFavorites.assertThat().entriesListIsEmpty().assertThat().paginationField("skipCount").is("999999999"); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, + description = "Verify the get favorites request with properties parameter applied") + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + public void userIsAbleToGetFavoritesWithPropertiesParamApplied() throws Exception + { + userFavorites = restClient.authenticateUser(secondUserModel).withParams("properties=targetGuid").withCoreAPI().usingUser(secondUserModel).getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.OK); + + RestPersonFavoritesModel restPersonFavoritesModel = userFavorites.getEntries().get(0).onModel(); + restPersonFavoritesModel.assertThat().field("targetGuid").is(thirdSiteModel.getGuid()).and().field("createdAt").isNull(); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify entry details for get favorites response with Rest API") + public void checkResponseSchemaForGetFavorites() throws Exception + { + userFavorites = restClient.authenticateUser(secondUserModel).withCoreAPI().usingAuthUser().getFavorites(); + restClient.assertStatusCodeIs(HttpStatus.OK); + + RestPersonFavoritesModel restPersonFavoritesModel = userFavorites.getEntries().get(0).onModel(); + restPersonFavoritesModel.assertThat().field("targetGuid").is(thirdSiteModel.getGuid()); + + RestSiteModel restSiteModel = restPersonFavoritesModel.getTarget().getSite(); + restSiteModel.assertThat().field("visibility").is(thirdSiteModel.getVisibility()).and() + .field("guid").is(thirdSiteModel.getGuid()).and() + .field("description").is(thirdSiteModel.getDescription()).and() + .field("id").is(thirdSiteModel.getId()).and() + .field("title").is(thirdSiteModel.getTitle()); + } +} \ No newline at end of file diff --git a/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesSanityTests.java b/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesSanityTests.java index 35c671dba..38c0789f1 100644 --- a/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/favorites/GetFavoritesSanityTests.java @@ -42,9 +42,6 @@ public class GetFavoritesSanityTests extends RestTest secondFolderModel = dataContent.usingUser(adminUserModel).usingSite(firstSiteModel).createFolder(); firstFileModel = dataContent.usingUser(adminUserModel).usingResource(firstFolderModel).createContent(DocumentType.TEXT_PLAIN); secondFileModel = dataContent.usingUser(adminUserModel).usingResource(firstFolderModel).createContent(DocumentType.TEXT_PLAIN); - - firstSiteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(firstSiteModel).getSite().getGuidWithoutVersion()); - secondSiteModel.setGuid(restClient.authenticateUser(adminUserModel).withCoreAPI().usingSite(secondSiteModel).getSite().getGuidWithoutVersion()); usersWithRoles = dataUser.addUsersWithRolesToSite(firstSiteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, UserRole.SiteContributor); @@ -188,12 +185,13 @@ public class GetFavoritesSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY, description = "Verify user gets status code 401 if authentication call fails") @Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY }) - @Bug(id="MNT-16904") + @Bug(id = "MNT-16904", description = "fails only on environment with tenants") public void userIsNotAbleToRetrieveFavoritesIfAuthenticationFails() throws JsonToModelConversionException, Exception { UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); siteManager.setPassword("wrongPassword"); restClient.authenticateUser(siteManager).withCoreAPI().usingAuthUser().getFavorites(); - restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastExceptionContains(HttpStatus.UNAUTHORIZED.toString()); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED); } } diff --git a/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestFullTests.java b/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestFullTests.java index 1e60b408a..dd418e472 100644 --- a/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestFullTests.java +++ b/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestFullTests.java @@ -142,7 +142,15 @@ public class AddSiteMembershipRequestFullTests extends RestTest siteMembershipRequest = restClient.authenticateUser(regularUser).withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite); restClient.assertStatusCodeIs(HttpStatus.CREATED); siteMembershipRequest.assertThat().field("id").is(moderatedSite.getId()) + .assertThat().field("message").is("Please accept me") .assertThat().field("site").isNotEmpty(); + siteMembershipRequest.getSite() + .assertThat().field("visibility").is(moderatedSite.getVisibility()) + .assertThat().field("guid").is(moderatedSite.getGuid()) + .assertThat().field("description").is(moderatedSite.getDescription()) + .assertThat().field("id").is(moderatedSite.getId()) + .assertThat().field("title").is(moderatedSite.getTitle()); + siteMembershipRequests = restClient.withCoreAPI().usingAuthUser().getSiteMembershipRequests(); restClient.assertStatusCodeIs(HttpStatus.OK); siteMembershipRequests.assertThat().entriesListContains("id", moderatedSite.getId()) @@ -267,6 +275,23 @@ public class AddSiteMembershipRequestFullTests extends RestTest .assertLastError().containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, adminTenantUser.getUsername().toLowerCase(), publicSite.getId())); } + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL, TestGroup.NETWORKS }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify create site membership request returns status code 200 with tenant.") + public void addSiteMembershipRequestWithTenant() throws Exception + { + UserModel adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUser) + .usingTenant().createTenant(adminTenantUser); + UserModel tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + + SiteModel tenantPublicSite = dataSite.usingUser(adminTenantUser).createPublicRandomSite(); + siteMembershipRequest = restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteMembershipRequest(tenantPublicSite); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + siteMembershipRequest.assertThat().field("id").is(tenantPublicSite.getId()) + .assertThat().field("site").isNotEmpty(); + } + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify site membership request is automatically rejected when a site is switched from moderated to private") diff --git a/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestSanityTests.java b/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestSanityTests.java index 91f59b4ef..a248b6cb2 100644 --- a/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestSanityTests.java @@ -6,7 +6,6 @@ import org.alfresco.rest.model.RestErrorModel; import org.alfresco.rest.model.RestSiteMembershipRequestModel; import org.alfresco.utility.constants.UserRole; import org.alfresco.utility.data.DataUser; -import org.alfresco.utility.data.DataUser.ListUserWithRoles; import org.alfresco.utility.exception.DataPreparationException; import org.alfresco.utility.model.SiteModel; import org.alfresco.utility.model.TestGroup; diff --git a/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteCoreTests.java b/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteCoreTests.java index d01b95d7c..cb1c898da 100644 --- a/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteCoreTests.java +++ b/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteCoreTests.java @@ -30,7 +30,8 @@ public class DeleteFavoriteSiteCoreTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify user removes a site from favorites using '-me-' in place of personId with Rest API and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify user removes a site from favorites using '-me-' in place of personId with Rest API and response is successful (204)") public void removeFavoriteSiteWithSuccessUsingMeAsPersonId() throws Exception { restClient.authenticateUser(adminUserModel); @@ -42,7 +43,8 @@ public class DeleteFavoriteSiteCoreTests extends RestTest @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) @Bug(id = "REPO-1642", description = "reproduced on 5.2.1 only, it works on 5.2.0") - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify inexistent user is not able to remove a site from favorites and response is 404") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify inexistent user is not able to remove a site from favorites and response is 404") public void inexistentUserIsNotAbleToRemoveFavoriteSite() throws Exception { UserModel inexistentUser = new UserModel("inexistenUser", "password"); @@ -51,17 +53,24 @@ public class DeleteFavoriteSiteCoreTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify user is not able to remove from favorites a site with inexistent id and response is 404") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify user is not able to remove from favorites a site with inexistent id and response is 404") public void userIsNotAbleToRemoveFavoriteSiteWithInexistentId() throws Exception { SiteModel inexistentSite = new SiteModel("inexistentSite"); restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).removeFavoriteSite(inexistentSite); - restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError() - .containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, adminUserModel.getUsername(), inexistentSite.getTitle())); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, + adminUserModel.getUsername(), inexistentSite.getTitle())) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE) + .containsErrorKey(RestErrorModel.RELATIONSHIP_NOT_FOUND_ERRORKEY); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify manager user removes a site from its favorites and adds it again and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify manager user removes a site from its favorites and adds it again and response is successful (204)") public void managerUserRemovesFavoriteSiteAndAddItAgain() throws Exception { UserModel managerUser = dataUser.usingAdmin().createRandomTestUser(); @@ -75,7 +84,8 @@ public class DeleteFavoriteSiteCoreTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify manager user removes a site from its favorite sites list with Rest API and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify manager user removes a site from its favorite sites list with Rest API and response is successful (204)") public void managerUserRemovesFavoriteSiteWithSuccess() throws Exception { UserModel managerUser = dataUser.usingAdmin().createRandomTestUser(); @@ -88,7 +98,8 @@ public class DeleteFavoriteSiteCoreTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify uninvited user can delete favorite public site and response is 204") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify uninvited user can delete favorite public site and response is 204") public void uninvitedUserCanDeleteFavoritePublicSite() throws Exception { SiteModel publicSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite(); @@ -100,7 +111,8 @@ public class DeleteFavoriteSiteCoreTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify uninvited user can delete favorite moderated site and response is 204") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify uninvited user can delete favorite moderated site and response is 204") public void uninvitedUserCanDeleteFavoriteModeratedSite() throws Exception { SiteModel moderatedSiteModel = dataSite.usingUser(adminUserModel).createModeratedRandomSite(); @@ -112,7 +124,8 @@ public class DeleteFavoriteSiteCoreTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify user can delete favorite private site and response is 204") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify user can delete favorite private site and response is 204") public void userCanDeleteFavoritePrivateSite() throws Exception { SiteModel privateSiteModel = dataSite.usingUser(userModel).createPrivateRandomSite(); diff --git a/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteFullTests.java b/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteFullTests.java new file mode 100644 index 000000000..16d74659b --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteFullTests.java @@ -0,0 +1,185 @@ +package org.alfresco.rest.people; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.exception.JsonToModelConversionException; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestSiteModel; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.data.DataUser.ListUserWithRoles; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +public class DeleteFavoriteSiteFullTests extends RestTest +{ + UserModel userModel; + SiteModel siteModel, siteModel1; + UserModel adminUserModel, adminTenantUser, tenantUser; + RestSiteModel restSiteModel; + ListUserWithRoles usersWithRoles; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + userModel = dataUser.createRandomTestUser(); + siteModel = dataSite.usingUser(userModel).createPublicRandomSite(); + adminUserModel = dataUser.getAdminUser(); + + usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, + UserRole.SiteContributor); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }, executionType = ExecutionType.REGRESSION, + description = "User is not able to remove a favorite site of admin user") + public void userIsNotAbleToDeleteFavoritesOfAdmin() throws Exception + { + UserModel contributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor); + dataSite.usingUser(contributor).usingSite(siteModel).addSiteToFavorites(); + + restClient.authenticateUser(contributor) + .withCoreAPI().usingUser(adminUserModel).removeFavoriteSite(siteModel); + + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }, executionType = ExecutionType.REGRESSION, + description = "Users removed twice from favorites same site.") + public void managerUserRemovesDeletedFavoriteSite() throws Exception + { + UserModel managerUser = usersWithRoles.getOneUserWithRole(UserRole.SiteManager); + dataSite.usingUser(managerUser).usingSite(siteModel).addSiteToFavorites(); + + restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel); + restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.NOT_FAVOURITE_SITE, siteModel.getTitle())); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }, executionType = ExecutionType.REGRESSION, + description = "Users removes from favorite a site that is already deleted.") + public void consumerUserRemovesDeletedFavoriteSite() throws Exception + { + siteModel1 = dataSite.usingUser(userModel).createPublicRandomSite(); + UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser(); + dataUser.usingUser(userModel).addUserToSite(consumerUser, siteModel1, UserRole.SiteConsumer); + dataSite.usingUser(consumerUser).usingSite(siteModel1).addSiteToFavorites(); + + dataSite.usingAdmin().deleteSite(siteModel1); + restClient.authenticateUser(consumerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1); + + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, + consumerUser.getUsername(), siteModel1.getId())); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }, executionType = ExecutionType.REGRESSION, + description = "Delete favorite site that is NOT favorite.") + public void adminUserRemovesDeletedFavoriteSiteThatIsNotFavorite() throws Exception + { + siteModel = dataSite.usingUser(userModel).createPublicRandomSite(); + restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel); + + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError() + .containsSummary(String.format(RestErrorModel.NOT_FAVOURITE_SITE, siteModel.getTitle())); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify user doesn't have permission to delete favorites of another user with Rest API and status code is 403") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + public void userIsNotAbleToDeleteFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception + { + UserModel siteCollaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator); + dataSite.usingUser(siteCollaborator).usingSite(siteModel).addSiteToFavorites(); + + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)) + .withCoreAPI() + .usingUser(siteCollaborator) + .removeFavoriteSite(siteModel); + + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id="MNT-16904") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.NETWORKS }, executionType = ExecutionType.REGRESSION, + description = "Verify tenant user is not able to delete favorites using an invalid network ID") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE,TestGroup.NETWORKS, TestGroup.FULL }) + public void tenantIsNotAbleToDeleteFavoriteSiteWithInvalidNetworkID() throws JsonToModelConversionException, Exception + { + adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser); + tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + siteModel = dataSite.usingUser(tenantUser).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(tenantUser).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + tenantUser.setDomain("invalidNetwork"); + + restClient.withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError() + .containsSummary(RestErrorModel.AUTHENTICATION_FAILED) + .containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.NETWORKS }, executionType = ExecutionType.REGRESSION, + description = "Verify tenant user deletes favorites site and status code is (204)") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE,TestGroup.NETWORKS, TestGroup.FULL }) + public void tenantDeleteFavoriteSiteValidNetwork() throws JsonToModelConversionException, Exception + { + adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser); + tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + siteModel = dataSite.usingUser(tenantUser).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(tenantUser).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + tenantUser.setDomain(tenantUser.getDomain()); + + restClient.withCoreAPI() + .usingAuthUser().removeFavoriteSite(siteModel); + restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuidWithoutVersion()); + } + + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.NETWORKS }, executionType = ExecutionType.REGRESSION, + description = "Verify tenant user deletes favorites site created by admin tenant - same network and status code is (204)") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE,TestGroup.NETWORKS, TestGroup.FULL }) + public void tenantUserIsAbleToDeleteFavoriteSiteAddedByAdminSameNetwork() throws JsonToModelConversionException, Exception + { + adminTenantUser = UserModel.getAdminTenantUser(); + restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser); + tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant"); + siteModel = dataSite.usingUser(adminTenantUser).createPublicRandomSite(); + siteModel.setGuid(restClient.authenticateUser(adminTenantUser).withCoreAPI().usingSite(siteModel).getSite().getGuid()); + restClient.authenticateUser(tenantUser).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel); + tenantUser.setDomain(adminTenantUser.getDomain()); + + restClient.withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel); + restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel.getGuidWithoutVersion()); + } + +} diff --git a/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteSanityTests.java b/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteSanityTests.java index ab56d7b8c..2e91ed8e2 100644 --- a/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteSanityTests.java @@ -33,7 +33,8 @@ public class DeleteFavoriteSiteSanityTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user removes a site from its favorite sites list with Rest API and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, + description = "Verify manager user removes a site from its favorite sites list with Rest API and response is successful (204)") public void managerUserRemovesFavoriteSiteWithSuccess() throws Exception { UserModel managerUser = dataUser.usingAdmin().createRandomTestUser(); @@ -43,10 +44,19 @@ public class DeleteFavoriteSiteSanityTests extends RestTest restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1); restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel1.getGuid()) + .and().entriesListDoesNotContain("id", siteModel1.getId()) + .and().entriesListDoesNotContain("description", siteModel1.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel1.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel1.getTitle()); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify collaborator user removes a site from its favorite sites list with Rest API and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, + description = "Verify collaborator user removes a site from its favorite sites list with Rest API and response is successful (204)") public void collaboratorUserRemovesFavoriteSiteWithSuccess() throws Exception { UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser(); @@ -56,10 +66,19 @@ public class DeleteFavoriteSiteSanityTests extends RestTest restClient.authenticateUser(collaboratorUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1); restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel1.getGuid()) + .and().entriesListDoesNotContain("id", siteModel1.getId()) + .and().entriesListDoesNotContain("description", siteModel1.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel1.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel1.getTitle()); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify contributor user removes a site from its favorite sites list with Rest API and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, + description = "Verify contributor user removes a site from its favorite sites list with Rest API and response is successful (204)") public void contributorUserRemovesFavoriteSiteWithSuccess() throws Exception { UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser(); @@ -69,10 +88,19 @@ public class DeleteFavoriteSiteSanityTests extends RestTest restClient.authenticateUser(contributorUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1); restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel1.getGuid()) + .and().entriesListDoesNotContain("id", siteModel1.getId()) + .and().entriesListDoesNotContain("description", siteModel1.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel1.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel1.getTitle()); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify consumer user removes a site from its favorite sites list with Rest API and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, + description = "Verify consumer user removes a site from its favorite sites list with Rest API and response is successful (204)") public void consumerUserRemovesFavoriteSiteWithSuccess() throws Exception { UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser(); @@ -82,10 +110,19 @@ public class DeleteFavoriteSiteSanityTests extends RestTest restClient.authenticateUser(consumerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1); restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT); + + restClient.withCoreAPI().usingAuthUser().getFavorites() + .assertThat() + .entriesListDoesNotContain("targetGuid", siteModel1.getGuid()) + .and().entriesListDoesNotContain("id", siteModel1.getId()) + .and().entriesListDoesNotContain("description", siteModel1.getDescription()) + .and().entriesListDoesNotContain("visibility", siteModel1.getVisibility().toString()) + .and().entriesListDoesNotContain("title", siteModel1.getTitle()); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify admin user removes a site from any user's favorite sites list with Rest API and response is successful (204)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, + description = "Verify admin user removes a site from any user's favorite sites list with Rest API and response is successful (204)") public void adminUserRemovesAnyFavoriteSiteWithSuccess() throws Exception { UserModel adminUser = dataUser.getAdminUser(); @@ -98,8 +135,9 @@ public class DeleteFavoriteSiteSanityTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify a user removes a site from another user's favorite sites list with Rest API and response is permission denied (403)") - public void userUserRemovesAnotherUserFavoriteSiteWithSuccess() throws Exception + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, + description = "Verify a user removes a site from another user's favorite sites list with Rest API and response is permission denied (403)") + public void userRemovesAnotherUserFavoriteSiteWithSuccess() throws Exception { UserModel userAuth = dataUser.usingAdmin().createRandomTestUser(); UserModel anotherUser = dataUser.usingAdmin().createRandomTestUser(); @@ -107,11 +145,17 @@ public class DeleteFavoriteSiteSanityTests extends RestTest dataSite.usingUser(anotherUser).usingSite(siteModel2).addSiteToFavorites(); restClient.authenticateUser(userAuth).withCoreAPI().usingUser(anotherUser).removeFavoriteSite(siteModel1); - restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError() + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE) + .containsErrorKey(RestErrorModel.PERMISSION_DENIED_ERRORKEY); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user is NOT Authorized to remove a site from its favorite sites list with Rest API when authentication fails (401)") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, + description = "Verify manager user is NOT Authorized to remove a site from its favorite sites list with Rest API when authentication fails (401)") @Bug(id = "MNT-16904") public void managerUserNotAuthorizedFailsToRemoveFavoriteSite() throws Exception { @@ -122,6 +166,11 @@ public class DeleteFavoriteSiteSanityTests extends RestTest managerUser.setPassword("newpassword"); restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1); - restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastExceptionContains(HttpStatus.UNAUTHORIZED.toString()); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError() + .containsSummary(RestErrorModel.AUTHENTICATION_FAILED) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE) + .containsErrorKey(RestErrorModel.API_DEFAULT_ERRORKEY); } } diff --git a/e2e-test/java/org/alfresco/rest/people/GetFavoriteSiteFullTests.java b/e2e-test/java/org/alfresco/rest/people/GetFavoriteSiteFullTests.java new file mode 100644 index 000000000..06c9fd69b --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/GetFavoriteSiteFullTests.java @@ -0,0 +1,163 @@ +package org.alfresco.rest.people; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.core.RestRequest; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestSiteModel; +import org.alfresco.rest.model.RestSiteModelsCollection; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.apache.commons.lang3.RandomStringUtils; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatus; +import org.springframework.social.alfresco.api.entities.Site.Visibility; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +/** + * Created by Bogdan Bocancea + */ +public class GetFavoriteSiteFullTests extends RestTest +{ + UserModel userModel; + SiteModel site1; + private RestSiteModel restSiteModel; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + userModel = dataUser.createRandomTestUser(); + site1 = dataSite.usingUser(userModel).createPublicRandomSite(); + dataSite.usingUser(userModel).usingSite(site1).addSiteToFavorites(); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify invalid request returns status 404 when personId is invalid") + public void getFavoriteSiteWithInvalidPersonId() throws Exception + { + UserModel userSpecialChars = dataUser.usingAdmin().createUser(RandomStringUtils.randomAlphabetic(2) + "~!@#$%^&*()_+[]{}|;'d", "password"); + userSpecialChars.setUsername(RandomStringUtils.randomAlphabetic(2) + "~!%40%23%24%25%5E%26*()_%2B%5B%5D%7B%7D%7C%5C%3B%27%3A%22%2C.%2F%3C%3E"); + + restClient.authenticateUser(userModel).withCoreAPI().usingUser(userSpecialChars).getFavoriteSite(site1); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, userSpecialChars.getUsername())); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify request with empty site id") + public void getFavoriteSiteWithEmptySiteId() throws Exception + { + restClient.authenticateUser(userModel).withCoreAPI(); + RestRequest request = RestRequest.simpleRequest(HttpMethod.GET, "people/{personId}/favorite-sites/{siteId}?{parameters}", + userModel.getUsername(), "", restClient.getParameters()); + RestSiteModelsCollection sites = restClient.processModels(RestSiteModelsCollection.class, request); + restClient.assertStatusCodeIs(HttpStatus.OK); + sites.assertThat().entriesListIsNotEmpty(); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify invalid request returns status 401 when user is empty") + public void getFavoriteSiteWithEmptyPersonId() throws Exception + { + UserModel emptyUser = new UserModel("", "password"); + restClient.authenticateUser(emptyUser).withCoreAPI().usingAuthUser().getFavoriteSite(site1); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError() + .containsSummary(RestErrorModel.AUTHENTICATION_FAILED); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify invalid request returns status 404 when another user get favorite site of an user") + public void getFavoriteSiteWithAnotherUser() throws Exception + { + UserModel user = dataUser.createRandomTestUser(); + restClient.authenticateUser(user).withCoreAPI().usingAuthUser().getFavoriteSite(site1); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError() + .containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, user.getUsername(), site1.getId())) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE) + .containsErrorKey(RestErrorModel.RELATIONSHIP_NOT_FOUND_ERRORKEY); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify request returns status 200 when using -me-") + public void getFavoriteSiteUsingMe() throws Exception + { + restSiteModel = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getFavoriteSite(site1); + restClient.assertStatusCodeIs(HttpStatus.OK); + restSiteModel.assertThat().field("id").is(site1.getId()) + .and().field("title").is(site1.getTitle()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify entry details for get site favorite response with Rest API") + public void checkResponseSchemaForGetSiteFavorite() throws Exception + { + restSiteModel = restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser().getFavoriteSite(site1); + restClient.assertStatusCodeIs(HttpStatus.OK); + restSiteModel.assertThat().field("id").is(site1.getId()) + .and().field("title").is(site1.getTitle()) + .and().field("role").is(UserRole.SiteManager.toString()) + .and().field("visibility").is(Visibility.PUBLIC.toString()) + .and().field("guid").isNotEmpty() + .and().field("description").is(site1.getDescription()) + .and().field("preset").is("site-dashboard"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify invalid request returns status 404 when providing folder name instead of site id") + public void getFavoriteSiteUsingFolder() throws Exception + { + FolderModel folder = dataContent.usingUser(userModel).usingSite(site1).createFolder(); + SiteModel siteFolder = new SiteModel(folder.getName()); + restSiteModel = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getFavoriteSite(siteFolder); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError() + .containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, userModel.getUsername(), folder.getName())); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify request returns status 200 when using valid parameters") + public void getFavoriteSiteUsingParameters() throws Exception + { + restSiteModel = restClient.withParams("maxItems=100").authenticateUser(userModel).withCoreAPI().usingMe().getFavoriteSite(site1); + restClient.assertStatusCodeIs(HttpStatus.OK); + restSiteModel.assertThat().field("id").is(site1.getId()) + .and().field("title").is(site1.getTitle()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify request returns status 400 when using maxItems=0") + public void getFavoriteSiteUsingInvalidMaxItems() throws Exception + { + restSiteModel = restClient.withParams("maxItems=0").authenticateUser(userModel).withCoreAPI().usingMe().getFavoriteSite(site1); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, + description = "Verify request returns status 200 when using -me-") + public void getFavoriteSiteUsingInvalidNetwork() throws Exception + { + UserModel invalidUserNetwork = dataUser.createRandomTestUser(); + SiteModel site = dataSite.usingUser(invalidUserNetwork).createPublicRandomSite(); + dataSite.usingUser(invalidUserNetwork).usingSite(site).addSiteToFavorites(); + invalidUserNetwork.setDomain("invalidNetwork"); + restSiteModel = restClient.authenticateUser(invalidUserNetwork).withCoreAPI().usingMe().getFavoriteSite(site); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED); + } +} diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesCoreTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesCoreTests.java new file mode 100644 index 000000000..cd86f55be --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesCoreTests.java @@ -0,0 +1,126 @@ +package org.alfresco.rest.people; + +import org.alfresco.dataprep.CMISUtil.DocumentType; +import org.alfresco.rest.RestTest; +import org.alfresco.rest.model.RestActivityModelsCollection; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.model.FileModel; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +/** + * + * @author Cristina Axinte + * + */ +public class GetPeopleActivitiesCoreTests extends RestTest +{ + UserModel userModel, adminUser, managerUser; + SiteModel siteModel1, siteModel2; + FileModel fileInSite1, fileInSite2; + FolderModel folderInSite2; + private RestActivityModelsCollection restActivityModelsCollection; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUser = dataUser.getAdminUser(); + userModel = dataUser.createRandomTestUser(); + siteModel1 = dataSite.usingUser(userModel).createPublicRandomSite(); + fileInSite1 = dataContent.usingUser(userModel).usingSite(siteModel1).createContent(DocumentType.TEXT_PLAIN); + + siteModel2 = dataSite.usingUser(userModel).createPublicRandomSite(); + folderInSite2 = dataContent.usingUser(userModel).usingSite(siteModel2).createFolder(); + fileInSite2 = dataContent.usingAdmin().usingSite(siteModel2).createContent(DocumentType.TEXT_PLAIN); + + managerUser = dataUser.createRandomTestUser(); + dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel2, UserRole.SiteManager); + + // only once the activity list is checked with retry in order not to wait the entire list in each test + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getPersonActivitiesUntilEntriesCountIs(4); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("4"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user cannot get activities for inexistent user with Rest API and response is 404") + public void userCannotGetPeopleActivitiesForInexistentPersonId() throws Exception + { + UserModel inexistentUserName = new UserModel("inexistent", "password"); + + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(inexistentUserName).getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError().containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY) + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, inexistentUserName.getUsername())) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its activities for inexistent siteId with Rest API and response is 404") + public void userGetItsPeopleActivitiesForInexistentSite() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).usingParams(String.format("siteId=inexistent")).getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError().containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY) + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "inexistent")) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities with invald skipCount parameter with Rest API and response is 400") + public void userGetPeopleActivitiesUsingInvalidSkipCountParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().usingParams("skipCount=-1").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsErrorKey(RestErrorModel.NEGATIVE_VALUES_SKIPCOUNT) + .containsSummary(RestErrorModel.NEGATIVE_VALUES_SKIPCOUNT) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities with invalid maxItems parameter with Rest API and response is 400") + public void userGetPeopleActivitiesUsingInvalidMaxItemsParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().usingParams("maxItems=0").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsErrorKey(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS) + .containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities using invalid value for parameter 'who'with Rest API and response is 400") + public void userGetsPeopleActivitiesUsingInvalidValueForWhoParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).usingParams("who=mee").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsErrorKey(RestErrorModel.INVALID_PARAMETER_WHO) + .containsSummary(RestErrorModel.INVALID_PARAMETER_WHO) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities successfully using parameter 'who' with 'others' value with Rest API") + public void userGetsPeopleActivitiesUsingOthersForWhoParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).usingParams("who=others").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("2"); + restActivityModelsCollection.assertThat().entriesListDoesNotContain("postPersonId", userModel.getUsername().toLowerCase()) + .and().entriesListContains("postPersonId", adminUser.getUsername().toLowerCase()) + .and().entriesListContains("postPersonId", managerUser.getUsername().toLowerCase()); + } +} diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesFullTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesFullTests.java new file mode 100644 index 000000000..ffe5b50d9 --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesFullTests.java @@ -0,0 +1,224 @@ +package org.alfresco.rest.people; + +import java.util.ArrayList; +import java.util.List; + +import org.alfresco.dataprep.CMISUtil.DocumentType; +import org.alfresco.rest.RestTest; +import org.alfresco.rest.model.RestActivityModel; +import org.alfresco.rest.model.RestActivityModelsCollection; +import org.alfresco.rest.model.RestActivitySummaryModel; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.utility.constants.ActivityType; +import org.alfresco.utility.constants.UserRole; +import org.alfresco.utility.model.FileModel; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.Assert; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +/** + * + * @author Cristina Axinte + * + */ +public class GetPeopleActivitiesFullTests extends RestTest +{ + UserModel userModel, adminUser, managerUser; + SiteModel siteModel1, siteModel2; + FileModel fileInSite1, fileInSite2; + FolderModel folderInSite2; + private RestActivityModelsCollection restActivityModelsCollection; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUser = dataUser.getAdminUser(); + userModel = dataUser.createRandomTestUser(); + siteModel1 = dataSite.usingUser(userModel).createPublicRandomSite(); + fileInSite1 = dataContent.usingUser(userModel).usingSite(siteModel1).createContent(DocumentType.TEXT_PLAIN); + + siteModel2 = dataSite.usingUser(userModel).createPublicRandomSite(); + folderInSite2 = dataContent.usingUser(userModel).usingSite(siteModel2).createFolder(); + fileInSite2 = dataContent.usingAdmin().usingSite(siteModel2).createContent(DocumentType.TEXT_PLAIN); + + managerUser = dataUser.createRandomTestUser(); + dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel2, UserRole.SiteManager); + + // only once the activity list is checked with retry in order not to wait the entire list in each test + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getPersonActivitiesUntilEntriesCountIs(4); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("4"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its activities using me with Rest API and response is successful") + public void userGetsItsPeopleActivitiesUsingMe() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("4"); + + List allActivitySummary = new ArrayList(); + for (RestActivityModel activityModel: restActivityModelsCollection.getEntries()) + { + allActivitySummary.add(activityModel.onModel().getActivitySummary()); + } + + assertActivitySummaryTitleIsPresent(allActivitySummary, fileInSite1.getName()); + assertActivitySummaryTitleIsPresent(allActivitySummary, folderInSite2.getName()); + assertActivitySummaryTitleIsPresent(allActivitySummary, fileInSite2.getName()); + restActivityModelsCollection.assertThat().entriesListContains("activityType", ActivityType.USER_JOINED.toString()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify activity summary from user gets activities response with Rest API") + public void userGetPeopleActivitiesWithActivitySummaryCheck() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("4"); + RestActivitySummaryModel summary = restActivityModelsCollection.getEntries().get(0).onModel().getActivitySummary(); + summary.assertThat().field("firstName").is(managerUser.getUsername() + " FirstName") + .and().field("lastName").is("LN-" + managerUser.getUsername()) + .and().field("memberFirstName").is(managerUser.getUsername() + " FirstName") + .and().field("role").is(managerUser.getUserRole()) + .and().field("memberLastName").is("LN-" + managerUser.getUsername()) + .and().field("title").is(String.format("%s FirstName LN-%s (%s)", managerUser.getUsername(), managerUser.getUsername(), managerUser.getUsername())) + .and().field("memberPersonId").is(managerUser.getUsername()); + } + + @Bug(id = "ACE-5460") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user cannot get activities for empty user with Rest API and response is 400") + public void userCannotGetPeopleActivitiesForEmptyPersonId() throws Exception + { + UserModel emptyUserName = new UserModel("", "password"); + + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(emptyUserName).getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY) + .containsSummary(RestErrorModel.LOCAL_NAME_CONSISTANCE) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities successfully using parameter 'who' with 'me' value with Rest API") + public void userGetsPeopleActivitiesUsingMeForWhoParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).usingParams("who=me").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("2"); + restActivityModelsCollection.assertThat().entriesListContains("postPersonId", userModel.getUsername().toLowerCase()) + .and().entriesListDoesNotContain("postPersonId", adminUser.getUsername().toLowerCase()) + .and().entriesListDoesNotContain("postPersonId", managerUser.getUsername().toLowerCase()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its activities for siteId specified in siteId parameter using me with Rest API and response is successful") + public void userGetItsPeopleActivitiesForASpecificSite() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).usingParams(String.format("siteId=%s", siteModel1.getId())).getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("1"); + restActivityModelsCollection.assertThat().entriesListContains("siteId", siteModel1.getId()) + .and().entriesListDoesNotContain("siteId", siteModel2.getId()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities for user with no activities with Rest API and response is successful") + public void userGetPeopleActivitiesForUserWithNoActivities() throws Exception + { + UserModel userNoActivities = dataUser.createRandomTestUser(); + dataSite.usingUser(userNoActivities).createPublicRandomSite(); + + restActivityModelsCollection = restClient.authenticateUser(adminUser).withCoreAPI().usingUser(userNoActivities).getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("0"); + restActivityModelsCollection.assertThat().entriesListIsEmpty(); + } + + private void assertActivitySummaryTitleIsPresent(List allActivitySummary, String title) + { + for (RestActivitySummaryModel activitySummary: allActivitySummary) + { + if (activitySummary.getTitle().equals(title)) + { + Assert.assertEquals(activitySummary.getTitle(), title, String.format("%s title was not found in Activity Summary", title)); + break; + } + } + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user cannot get activities for siteId that user doesn't have access to with Rest API and response is not found") + public void userGetPeopleActivitiesForASiteWithNoAccess() throws Exception + { + SiteModel siteNoAccess = dataSite.usingUser(managerUser).createPrivateRandomSite(); + + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).usingParams(String.format("siteId=%s", siteNoAccess.getId())).getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND); + restClient.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, siteNoAccess.getId())); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user cannot get activities for another user with Rest API and response is permission denied") + public void userGetPeopleActivitiesForAnotherUser() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingUser(managerUser).getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); + restClient.assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities with properties parameter applied with Rest API and response is successful") + public void userGetPeopleActivitiesUsingPropertiesParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().usingParams("properties=postPersonId").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("4"); + restActivityModelsCollection.assertThat().entriesListContains("postPersonId", userModel.getUsername().toLowerCase()) + .and().entriesListContains("postPersonId", adminUser.getUsername().toLowerCase()) + .and().entriesListContains("postPersonId", managerUser.getUsername().toLowerCase()) + .and().entriesListDoesNotContain("postedAt") + .and().entriesListDoesNotContain("feedPersonId") + .and().entriesListDoesNotContain("siteId") + .and().entriesListDoesNotContain("activitySummary") + .and().entriesListDoesNotContain("id") + .and().entriesListDoesNotContain("activityType"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities with skipCount parameter applied with Rest API and response is successful") + public void userGetPeopleActivitiesUsingSkipCountParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().usingParams("skipCount=2").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("2"); + restActivityModelsCollection.getEntries().get(0).onModel().assertThat().field("postPersonId").is(userModel.getUsername().toLowerCase()) + .and().field("activityType").is(ActivityType.FOLDER_ADDED.toString()); + restActivityModelsCollection.getEntries().get(1).onModel().assertThat().field("postPersonId").is(userModel.getUsername().toLowerCase()) + .and().field("activityType").is(ActivityType.FILE_ADDED.toString()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets activities with maxItems parameter applied with Rest API and response is successful") + public void userGetPeopleActivitiesUsingMaxItemsParameter() throws Exception + { + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().usingParams("maxItems=2").getPersonActivities(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restActivityModelsCollection.assertThat().paginationField("count").is("2"); + restActivityModelsCollection.getEntries().get(0).onModel().assertThat().field("postPersonId").is(managerUser.getUsername().toLowerCase()) + .and().field("activityType").is(ActivityType.USER_JOINED.toString()); + restActivityModelsCollection.getEntries().get(1).onModel().assertThat().field("postPersonId").is(adminUser.getUsername().toLowerCase()) + .and().field("activityType").is(ActivityType.FILE_ADDED.toString()); + } +} diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesSanityTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesSanityTests.java index 0e3f3cd59..f0b91dce5 100644 --- a/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesSanityTests.java @@ -37,6 +37,10 @@ public class GetPeopleActivitiesSanityTests extends RestTest UserRole.SiteContributor); unauthenticatedUser = dataUser.usingAdmin().createRandomTestUser(); unauthenticatedUser.setPassword("newpassword"); + + // only once the activity list is checked with retry in order not to wait the entire list in each test + restActivityModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser().getPersonActivitiesUntilEntriesCountIs(5); + restClient.assertStatusCodeIs(HttpStatus.OK); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.ACTIVITIES, TestGroup.SANITY }) diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeopleCoreTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeopleCoreTests.java index c1ef69a85..3d814d594 100644 --- a/e2e-test/java/org/alfresco/rest/people/GetPeopleCoreTests.java +++ b/e2e-test/java/org/alfresco/rest/people/GetPeopleCoreTests.java @@ -2,7 +2,6 @@ package org.alfresco.rest.people; import org.alfresco.rest.RestTest; import org.alfresco.rest.model.RestErrorModel; -import org.alfresco.rest.model.RestPersonModel; import org.alfresco.utility.constants.UserRole; import org.alfresco.utility.model.SiteModel; import org.alfresco.utility.model.TestGroup; diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceCoreTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceCoreTests.java index 759229be7..e2b943312 100644 --- a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceCoreTests.java +++ b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceCoreTests.java @@ -30,7 +30,7 @@ public class GetPeoplePreferenceCoreTests extends RestTest { UserModel secondUser = dataUser.createRandomTestUser(); restClient.authenticateUser(secondUser).withCoreAPI().usingUser(userModel) - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); restClient.assertLastError().containsSummary("Permission was denied"); } @@ -40,7 +40,7 @@ public class GetPeoplePreferenceCoreTests extends RestTest public void statusNotFoundIsReturnedForAPersonIDThatDoesNotExist() throws Exception { restClient.authenticateUser(userModel).withCoreAPI().usingUser(new UserModel("invalidPersonID", "password")) - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND); restClient.assertLastError().containsSummary("The entity with id: invalidPersonID was not found"); } @@ -57,17 +57,17 @@ public class GetPeoplePreferenceCoreTests extends RestTest } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify manager fails to get a specific preference for an removed preference with Rest API and response is 404") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify manager fails to get a specific preference for removed preference with Rest API and response is 404") public void statusNotFoundIsReturnedForAPreferenceNameThatHasBeenRemoved() throws Exception { SiteModel preferenceSite = dataSite.usingUser(userModel).createPublicRandomSite(); dataSite.usingUser(userModel).usingSite(preferenceSite).addSiteToFavorites(); dataSite.usingUser(userModel).usingSite(preferenceSite).removeSiteFromFavorites(); restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser() - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + preferenceSite.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), preferenceSite.getId())); restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND); restClient.assertLastError().containsSummary( String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", userModel.getUsername(), - PreferenceName.SITES_FAVORITES_PREFIX + preferenceSite.getId())); + String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), preferenceSite.getId()))); } } diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceFullTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceFullTests.java new file mode 100644 index 000000000..f9f310fde --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceFullTests.java @@ -0,0 +1,222 @@ +package org.alfresco.rest.people; + +import java.nio.file.Paths; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestPreferenceModel; +import org.alfresco.utility.Utility; +import org.alfresco.utility.constants.PreferenceName; +import org.alfresco.utility.model.FileModel; +import org.alfresco.utility.model.FileType; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +public class GetPeoplePreferenceFullTests extends RestTest +{ + private UserModel userModel; + private SiteModel siteModel; + private RestPreferenceModel restPreferenceModel; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + userModel = dataUser.createRandomTestUser(); + siteModel = dataSite.usingUser(userModel).createPublicRandomSite(); + dataSite.usingUser(userModel).usingSite(siteModel).addSiteToFavorites(); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Check default error schema in case of failure") + public void checkDefaultErrorSchema() throws Exception + { + restClient.authenticateUser(userModel).withCoreAPI().usingUser(new UserModel("invalidPersonID", "password")) + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError() + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "invalidPersonID")) + .statusCodeIs(HttpStatus.NOT_FOUND) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE) + .containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Specify -me- string in place of for request") + public void preferenceIsReturnedWhenUsingMeAsPersonId() throws Exception + { + restPreferenceModel = restClient.authenticateUser(userModel).withCoreAPI().usingMe() + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); + + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().field("value").is("true"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Check that properties parameter is applied") + public void propertiesParameterIsAppliedWhenRetrievingPreference() throws Exception + { + restPreferenceModel = restClient.authenticateUser(userModel).withParams("properties=id").withCoreAPI().usingUser(userModel) + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().field("value").isNull(); + + restPreferenceModel = restClient.authenticateUser(userModel).withParams("properties=id,value").withCoreAPI().usingUser(userModel) + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().field("value").is("true"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Validate ID element in get site preference response") + public void validateIdElementInGetSitePreferenceResponse() throws Exception + { + restPreferenceModel = restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().field("value").is("true"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Validate ID element in get folder preference response") + public void validateIdElementInGetFolderPreferenceResponse() throws Exception + { + FolderModel folderFavorite = new FolderModel("favoriteFolder"); + folderFavorite = dataContent.usingSite(siteModel).createFolder(folderFavorite); + dataContent.getContentActions().setFolderAsFavorite(userModel.getUsername(), userModel.getPassword(), siteModel.getId(), folderFavorite.getName()); + + restPreferenceModel = restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.FOLDERS_FAVORITES_PREFIX.toString()); + restPreferenceModel.assertThat().field("id").is(PreferenceName.FOLDERS_FAVORITES_PREFIX) + .and().field("value").is(Utility.removeLastSlash(Utility.buildPath("workspace://SpacesStore", folderFavorite.getNodeRef()))); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Validate ID element in get file preference response") + public void validateIdElementInGetFilePreferenceResponse() throws Exception + { + FileModel fileFavorite = new FileModel("favoriteFile", FileType.TEXT_PLAIN); + fileFavorite = dataContent.usingSite(siteModel).createContent(fileFavorite); + dataContent.getContentActions().setFileAsFavorite(userModel.getUsername(), userModel.getPassword(), siteModel.getId(), String.format("%s.%s", fileFavorite.getName(), fileFavorite.getFileType().extention)); + + restPreferenceModel = restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.DOCUMENTS_FAVORITES_PREFIX.toString()); + restPreferenceModel.assertThat().field("id").is(PreferenceName.DOCUMENTS_FAVORITES_PREFIX) + .and().field("value").is(Utility.removeLastSlash(Utility.buildPath("workspace://SpacesStore", fileFavorite.getNodeRefWithoutVersion()))); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Get preference of an user that has no preferences") + public void getPreferenceForUserWithoutPreferences() throws Exception + { + UserModel newUser = dataUser.createRandomTestUser(); + + restPreferenceModel = restClient.authenticateUser(newUser).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.DOCUMENTS_FAVORITES_PREFIX.toString()); + restClient.assertLastError().containsSummary( + String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", newUser.getUsername(), + PreferenceName.DOCUMENTS_FAVORITES_PREFIX.toString())); + + restPreferenceModel = restClient.authenticateUser(newUser).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.FOLDERS_FAVORITES_PREFIX.toString()); + restClient.assertLastError().containsSummary( + String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", newUser.getUsername(), + PreferenceName.FOLDERS_FAVORITES_PREFIX.toString())); + + restPreferenceModel = restClient.authenticateUser(newUser).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX.toString()); + restClient.assertLastError().containsSummary( + String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", newUser.getUsername(), + PreferenceName.SITES_FAVORITES_PREFIX.toString())); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Change one preference for an user then perform get call") + @Bug(id = "ACE-5736") + public void changePreferenceThenPerformGetPreferenceCall() throws Exception + { + UserModel newUser = dataUser.createRandomTestUser(); + SiteModel site = dataSite.usingUser(newUser).createPublicRandomSite(); + + dataSite.usingUser(newUser).usingSite(site).addSiteToFavorites(); + + FileModel fileFavorite = new FileModel("favoriteFile", FileType.TEXT_PLAIN); + fileFavorite = dataContent.usingSite(site).createContent(fileFavorite); + dataContent.getContentActions().setFileAsFavorite(newUser.getUsername(), newUser.getPassword(), site.getId(), String.format("%s.%s", fileFavorite.getName(), fileFavorite.getFileType().extention)); + + FolderModel folderFavorite = new FolderModel("favoriteFolder"); + folderFavorite = dataContent.usingSite(site).createFolder(folderFavorite); + dataContent.getContentActions().setFolderAsFavorite(newUser.getUsername(), newUser.getPassword(), site.getId(), folderFavorite.getName()); + + dataSite.usingUser(newUser).usingSite(site).removeSiteFromFavorites(); + dataContent.getContentActions().removeFavorite(newUser.getUsername(), newUser.getPassword(), site.getId(), folderFavorite.getName()); + dataContent.getContentActions().removeFavorite(newUser.getUsername(), newUser.getPassword(), site.getId(), Paths.get(fileFavorite.getCmisLocation()).getFileName().toString()); + + restPreferenceModel = restClient.authenticateUser(newUser).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.FOLDERS_FAVORITES_PREFIX.toString()); + restClient.assertLastError().containsSummary( + String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", newUser.getUsername(), + PreferenceName.FOLDERS_FAVORITES_PREFIX.toString())); + + restPreferenceModel = restClient.authenticateUser(newUser).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX.toString()); + restClient.assertLastError().containsSummary( + String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", newUser.getUsername(), + PreferenceName.SITES_FAVORITES_PREFIX.toString())); + + restPreferenceModel = restClient.authenticateUser(newUser).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.DOCUMENTS_FAVORITES_PREFIX.toString()); + restClient.assertLastError().containsSummary( + String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", newUser.getUsername(), + PreferenceName.DOCUMENTS_FAVORITES_PREFIX.toString())); + + restPreferenceModel = restClient.authenticateUser(newUser).withCoreAPI().usingAuthUser() + .getPersonPreferenceInformation(PreferenceName.FOLDERS_FAVORITES_PREFIX.toString()); + restClient.assertLastError().containsSummary( + String.format("The relationship resource was not found for the" + " entity with id: %s and a relationship id of %s", newUser.getUsername(), + PreferenceName.FOLDERS_FAVORITES_PREFIX.toString())); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Verify admin is able to get preference of another user") + public void adminIsAbleToGetOtherUserPreference() throws Exception + { + restPreferenceModel = restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(userModel) + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())).and().field("value").is("true"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, + description = "Verify regular user is not able to get preference of admin user") + public void regularUserIsNotAbleToGetAdminPreference() throws Exception + { + SiteModel newSite = dataSite.usingUser(dataUser.getAdminUser()).createPublicRandomSite(); + dataSite.usingUser(dataUser.getAdminUser()).usingSite(newSite).addSiteToFavorites(); + + restClient.authenticateUser(userModel).withCoreAPI().usingUser(dataUser.getAdminUser()) + .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + newSite.getId()); + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); + restClient.assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } +} \ No newline at end of file diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceSanityTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceSanityTests.java index 525a693a5..74013fd91 100644 --- a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceSanityTests.java @@ -42,9 +42,9 @@ public class GetPeoplePreferenceSanityTests extends RestTest dataSite.usingUser(managerUser).usingSite(siteModel).addSiteToFavorites(); restPreferenceModel = restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser() - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.OK); - restPreferenceModel.assertThat().field("id").is(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()).and().field("value").is("true"); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())).and().field("value").is("true"); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -56,9 +56,9 @@ public class GetPeoplePreferenceSanityTests extends RestTest dataSite.usingUser(collaboratorUser).usingSite(siteModel).addSiteToFavorites(); restPreferenceModel = restClient.authenticateUser(collaboratorUser).withCoreAPI().usingAuthUser() - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.OK); - restPreferenceModel.assertThat().field("id").is(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()).and().field("value").is("true"); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())).and().field("value").is("true"); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -70,9 +70,9 @@ public class GetPeoplePreferenceSanityTests extends RestTest dataSite.usingUser(contributorUser).usingSite(siteModel).addSiteToFavorites(); restPreferenceModel = restClient.authenticateUser(contributorUser).withCoreAPI().usingAuthUser() - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.OK); - restPreferenceModel.assertThat().field("id").is(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()).and().field("value").is("true"); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())).and().field("value").is("true"); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -84,9 +84,9 @@ public class GetPeoplePreferenceSanityTests extends RestTest dataSite.usingUser(consumerUser).usingSite(siteModel).addSiteToFavorites(); restPreferenceModel = restClient.authenticateUser(consumerUser).withCoreAPI().usingAuthUser() - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(),siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.OK); - restPreferenceModel.assertThat().field("id").is(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()).and().field("value").is("true"); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(),siteModel.getId())).and().field("value").is("true"); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -97,9 +97,9 @@ public class GetPeoplePreferenceSanityTests extends RestTest dataSite.usingUser(adminUser).usingSite(siteModel).addSiteToFavorites(); restPreferenceModel = restClient.authenticateUser(adminUser).withCoreAPI().usingAuthUser() - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.OK); - restPreferenceModel.assertThat().field("id").is(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()).and().field("value").is("true"); + restPreferenceModel.assertThat().field("id").is(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())).and().field("value").is("true"); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -113,7 +113,7 @@ public class GetPeoplePreferenceSanityTests extends RestTest managerUser.setPassword("newpassword"); restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser() - .getPersonPreferenceInformation(PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .getPersonPreferenceInformation(String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastExceptionContains(HttpStatus.UNAUTHORIZED.toString()); } } diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesCoreTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesCoreTests.java new file mode 100644 index 000000000..94ea64631 --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesCoreTests.java @@ -0,0 +1,123 @@ +package org.alfresco.rest.people; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestPreferenceModelsCollection; +import org.alfresco.utility.constants.PreferenceName; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +/** + * + * @author Cristina Axinte + * + */ +public class GetPeoplePreferencesCoreTests extends RestTest +{ + UserModel userModel, user1, user2, adminUser; + SiteModel siteModel; + FolderModel folderModel; + private RestPreferenceModelsCollection restPreferenceModelsCollection; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUser = dataUser.getAdminUser(); + userModel = dataUser.createRandomTestUser(); + siteModel = dataSite.usingUser(userModel).createPublicRandomSite(); + folderModel = dataContent.usingUser(userModel).usingSite(siteModel).createFolder(); + + user1 = dataUser.createRandomTestUser(); + dataSite.usingUser(user1).usingSite(siteModel).addSiteToFavorites(); + dataContent.usingUser(user1).usingSite(siteModel).addFolderToFavorites(folderModel); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its preferences with invalid maxItems parameter with Rest API and response is 400") + public void userGetsPeoplePreferencesUsingInvalidMaxItemsParameter() throws Exception + { + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingMe().usingParams("maxItems=0").getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsErrorKey(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS) + .containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its preferences with skipCount parameter applied with Rest API and response is successful") + public void userGetsPeoplePreferencesUsingInvalidSkipCountParameter() throws Exception + { + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingMe().usingParams("skipCount=-1").getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsErrorKey(RestErrorModel.NEGATIVE_VALUES_SKIPCOUNT) + .containsSummary(RestErrorModel.NEGATIVE_VALUES_SKIPCOUNT) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user which doesn't have access to another user preferences fails to get its preferences with Rest API and response is permission denied") + public void userWithNoAccessToOtherUserPreferencesIsForbiddenToGetItsPreferences() throws Exception + { + UserModel noAccessUser = dataUser.createRandomTestUser(); + dataSite.usingUser(noAccessUser).usingSite(siteModel).addSiteToFavorites(); + + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingUser(noAccessUser).getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); + restClient.assertLastError().containsErrorKey(RestErrorModel.PERMISSION_DENIED_ERRORKEY) + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user fails to get preferences for inexistent personId with Rest API and response is 404") + public void userCannotGetPeoplePreferencesForInexistentPersonId() throws Exception + { + UserModel inexistentUserName = new UserModel("inexistent", "password"); + + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingUser(inexistentUserName).getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND); + restClient.assertLastError().containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY) + .containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, inexistentUserName.getUsername())) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user get preferences for a user with no preferences with Rest API and response is empty") + public void userGetsPeoplePreferencesForUserWithNoPreferences() throws Exception + { + UserModel userNoActivities = dataUser.createRandomTestUser(); + + restPreferenceModelsCollection = restClient.authenticateUser(adminUser).withCoreAPI().usingUser(userNoActivities).getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModelsCollection.assertThat().paginationField("count").is("0"); + restPreferenceModelsCollection.assertThat().entriesListIsEmpty(); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.CORE }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user fails to get preferences for a removed preference with Rest API and response is 404") + public void userFailsToGetPeoplePreferencesIfPreferenceWasRemoved() throws Exception + { + SiteModel preferenceSite = dataSite.usingUser(user1).createPublicRandomSite(); + dataSite.usingUser(user1).usingSite(preferenceSite).addSiteToFavorites(); + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingAuthUser().getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModelsCollection.assertThat().paginationField("count").is("6"); + + dataSite.usingUser(user1).usingSite(preferenceSite).removeSiteFromFavorites(); + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingAuthUser().getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModelsCollection.assertThat().paginationField("count").is("5"); + restPreferenceModelsCollection.assertThat().entriesListDoesNotContain("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), preferenceSite.getId())); + } +} diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesFullTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesFullTests.java new file mode 100644 index 000000000..8eda8ca1f --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesFullTests.java @@ -0,0 +1,130 @@ +package org.alfresco.rest.people; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestPreferenceModelsCollection; +import org.alfresco.utility.constants.PreferenceName; +import org.alfresco.utility.model.FolderModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +/** + * + * @author Cristina Axinte + * + */ +public class GetPeoplePreferencesFullTests extends RestTest +{ + UserModel userModel, user1, user2, adminUser; + SiteModel siteModel; + FolderModel folderModel; + private RestPreferenceModelsCollection restPreferenceModelsCollection; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + adminUser = dataUser.getAdminUser(); + userModel = dataUser.createRandomTestUser(); + siteModel = dataSite.usingUser(userModel).createPublicRandomSite(); + folderModel = dataContent.usingUser(userModel).usingSite(siteModel).createFolder(); + + user1 = dataUser.createRandomTestUser(); + dataSite.usingUser(user1).usingSite(siteModel).addSiteToFavorites(); + dataContent.usingUser(user1).usingSite(siteModel).addFolderToFavorites(folderModel); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its preferences using me with Rest API and response is successful") + public void userGetsItsPeoplePreferencesUsingMe() throws Exception + { + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingMe().getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModelsCollection.assertThat().paginationField("count").is("4"); + restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty() + .and().entriesListContains("id", String.format(PreferenceName.EXT_FOLDERS_FAVORITES_PREFIX.toString(), "workspace://SpacesStore/" + folderModel.getNodeRef())) + .and().entriesListContains("id", String.format(PreferenceName.EXT_SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().entriesListContains("id", PreferenceName.FOLDERS_FAVORITES_PREFIX.toString()) + .and().entriesListContains("value", "workspace://SpacesStore/" + folderModel.getNodeRef()) + .and().entriesListContains("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().entriesListContains("value", "true"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its preferences with skipCount parameter applied with Rest API and response is successful") + public void userGetsItsPeoplePreferencesUsingSkipCountParameter() throws Exception + { + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingMe().usingParams("skipCount=2").getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModelsCollection.assertThat().paginationField("count").is("2"); + restPreferenceModelsCollection.assertThat().paginationField("skipCount").is("2"); + restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty() + .and().entriesListDoesNotContain("id", String.format(PreferenceName.EXT_FOLDERS_FAVORITES_PREFIX.toString(), "workspace://SpacesStore/" + folderModel.getNodeRef())) + .and().entriesListDoesNotContain("id", String.format(PreferenceName.EXT_SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().entriesListContains("id", PreferenceName.FOLDERS_FAVORITES_PREFIX.toString()) + .and().entriesListContains("value", "workspace://SpacesStore/" + folderModel.getNodeRef()) + .and().entriesListContains("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().entriesListContains("value", "true"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its preferences with maxItems parameter applied with Rest API and response is successful") + public void userGetsItsPeoplePreferencesUsingMaxItemsParameter() throws Exception + { + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingMe().usingParams("maxItems=1").getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModelsCollection.assertThat().paginationField("count").is("1"); + restPreferenceModelsCollection.assertThat().paginationField("maxItems").is("1"); + restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty() + .and().entriesListContains("id", String.format(PreferenceName.EXT_FOLDERS_FAVORITES_PREFIX.toString(), "workspace://SpacesStore/" + folderModel.getNodeRef())) + .and().entriesListDoesNotContain("id", String.format(PreferenceName.EXT_SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().entriesListDoesNotContain("id", PreferenceName.FOLDERS_FAVORITES_PREFIX.toString()) + .and().entriesListDoesNotContain("value", "workspace://SpacesStore/" + folderModel.getNodeRef()) + .and().entriesListDoesNotContain("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())) + .and().entriesListDoesNotContain("value", "true"); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets admin preferences with Rest API and response is permission denied") + public void userIsForbiddenToGetAdminPreferences() throws Exception + { + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingUser(adminUser).getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); + restClient.assertLastError().containsErrorKey(RestErrorModel.PERMISSION_DENIED_ERRORKEY) + .containsSummary(RestErrorModel.PERMISSION_WAS_DENIED) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user gets its preferences with skipCount parameter higher then no of entries with Rest API and response is empty") + public void userGetsItsPeoplePreferencesUsingHighSkipCount() throws Exception + { + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingMe().usingParams("skipCount=100").getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.OK); + restPreferenceModelsCollection.assertThat().paginationField("count").is("0"); + restPreferenceModelsCollection.assertThat().paginationField("skipCount").is("100"); + restPreferenceModelsCollection.assertThat().entriesListIsEmpty(); + } + + @Bug(id = "ACE-5460") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES }, executionType = ExecutionType.REGRESSION, description = "Verify user cannot get preferences for empty user with Rest API and response is 400") + public void userGetsItsPeoplePreferencesForEmptyPersonId() throws Exception + { + UserModel emptyUserName = new UserModel("", "password"); + + restPreferenceModelsCollection = restClient.authenticateUser(user1).withCoreAPI().usingUser(emptyUserName).getPersonPreferences(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY) + .containsSummary(RestErrorModel.LOCAL_NAME_CONSISTANCE) + .stackTraceIs(RestErrorModel.STACKTRACE) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER); + } +} diff --git a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesSanityTests.java b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesSanityTests.java index 933ee0ce5..6a871427f 100644 --- a/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesSanityTests.java @@ -44,7 +44,7 @@ public class GetPeoplePreferencesSanityTests extends RestTest restPreferenceModelsCollection = restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().getPersonPreferences(); restClient.assertStatusCodeIs(HttpStatus.OK); restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty().assertThat().paginationExist().and() - .entriesListContains("id", PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .entriesListContains("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -58,7 +58,7 @@ public class GetPeoplePreferencesSanityTests extends RestTest restPreferenceModelsCollection = restClient.authenticateUser(collaboratorUser).withCoreAPI().usingAuthUser().getPersonPreferences(); restClient.assertStatusCodeIs(HttpStatus.OK); restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty().assertThat().paginationExist().and() - .entriesListContains("id", PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .entriesListContains("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -72,7 +72,7 @@ public class GetPeoplePreferencesSanityTests extends RestTest restPreferenceModelsCollection = restClient.authenticateUser(contributorUser).withCoreAPI().usingAuthUser().getPersonPreferences(); restClient.assertStatusCodeIs(HttpStatus.OK); restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty().assertThat().paginationExist().and() - .entriesListContains("id", PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .entriesListContains("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -86,7 +86,7 @@ public class GetPeoplePreferencesSanityTests extends RestTest restPreferenceModelsCollection = restClient.authenticateUser(consumerUser).withCoreAPI().usingAuthUser().getPersonPreferences(); restClient.assertStatusCodeIs(HttpStatus.OK); restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty().assertThat().paginationExist().and() - .entriesListContains("id", PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .entriesListContains("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) @@ -101,7 +101,7 @@ public class GetPeoplePreferencesSanityTests extends RestTest restPreferenceModelsCollection = restClient.authenticateUser(adminUser).withCoreAPI().usingUser(managerUser).getPersonPreferences(); restClient.assertStatusCodeIs(HttpStatus.OK); restPreferenceModelsCollection.assertThat().entriesListIsNotEmpty().assertThat().paginationExist().and() - .entriesListContains("id", PreferenceName.SITES_FAVORITES_PREFIX + siteModel.getId()); + .entriesListContains("id", String.format(PreferenceName.SITES_FAVORITES_PREFIX.toString(), siteModel.getId())); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.PREFERENCES, TestGroup.SANITY }) diff --git a/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsCoreTests.java b/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsCoreTests.java index dae11e055..b82ea8998 100644 --- a/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsCoreTests.java +++ b/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsCoreTests.java @@ -35,30 +35,46 @@ public class GetSiteMembershipRequestsCoreTests extends RestTest newMember = dataUser.createRandomTestUser(); restClient.authenticateUser(newMember).withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite); - restClient.assertStatusCodeIs(HttpStatus.CREATED); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify that for invalid maxItems parameter status code returned is 400.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify that for invalid maxItems parameter status code returned is 400.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void checkInvalidMaxItemsStatusCode() throws Exception { - restClient.authenticateUser(adminUser).withParams("maxItems=AB").withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); - restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary("Invalid paging parameter"); + restClient.authenticateUser(adminUser).withParams("maxItems=AB") + .withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(String.format(RestErrorModel.INVALID_MAXITEMS, "AB")); + + restClient.authenticateUser(adminUser).withParams("maxItems=0") + .withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify that for invalid skipCount parameter status code returned is 400.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify that for invalid skipCount parameter status code returned is 400.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void checkInvalidSkipCountStatusCode() throws Exception { - restClient.authenticateUser(adminUser).withParams("skipCount=AB").withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); - restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary("Invalid paging parameter"); + restClient.authenticateUser(adminUser).withParams("skipCount=AB") + .withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(String.format(RestErrorModel.INVALID_SKIPCOUNT, "AB")); + + restClient.authenticateUser(adminUser).withParams("skipCount=-1") + .withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST) + .assertLastError().containsSummary(RestErrorModel.NEGATIVE_VALUES_SKIPCOUNT); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify that if personId does not exist status code returned is 404.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify that if personId does not exist status code returned is 404.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void ifPersonIdDoesNotExist() throws Exception { @@ -66,11 +82,17 @@ public class GetSiteMembershipRequestsCoreTests extends RestTest nonexistentUser.setUsername("nonexistent"); restClient.authenticateUser(adminUser).withCoreAPI().usingUser(nonexistentUser).getSiteMembershipRequests(); - restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "nonexistent")); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "nonexistent")) + .statusCodeIs(HttpStatus.NOT_FOUND) + .descriptionURLIs(RestErrorModel.RESTAPIEXPLORER) + .stackTraceIs(RestErrorModel.STACKTRACE) + .containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Specify -me- string in place of for request.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Specify -me- string in place of for request.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void replacePersonIdWithMeRequest() throws Exception { @@ -81,7 +103,9 @@ public class GetSiteMembershipRequestsCoreTests extends RestTest returnedCollection.assertThat().entriesListContains("id", moderatedSite.getId()); } - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify that if empty personId is used status code returned is 404.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify that if empty personId is used status code returned is 404.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void useEmptyPersonId() throws Exception { @@ -89,11 +113,13 @@ public class GetSiteMembershipRequestsCoreTests extends RestTest emptyNameMember.setUsername(" "); restClient.authenticateUser(adminUser).withCoreAPI().usingUser(emptyNameMember).getSiteMembershipRequests(); - restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary("The entity with id: " + emptyNameMember.getUsername() + " was not found"); + restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND) + .assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, emptyNameMember.getUsername())); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Get site membership requests to a public site.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Get site membership requests to a public site.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void getRequestsToPublicSite() throws Exception { @@ -105,8 +131,9 @@ public class GetSiteMembershipRequestsCoreTests extends RestTest returnedCollection.assertThat().entriesListDoesNotContain("id", publicSite.getId()); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Get site membership requests to a moderated site.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Get site membership requests to a moderated site.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void getRequestsToModeratedSite() throws Exception { @@ -117,7 +144,9 @@ public class GetSiteMembershipRequestsCoreTests extends RestTest returnedCollection.assertThat().entriesListContains("id", moderatedSite.getId()); } - @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Approve request then get requests.") + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Approve request then get requests.") @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE }) public void approveRequestThenGetRequests() throws Exception { diff --git a/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsFullTests.java b/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsFullTests.java new file mode 100644 index 000000000..59bcf2b5a --- /dev/null +++ b/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsFullTests.java @@ -0,0 +1,170 @@ +package org.alfresco.rest.people; + +import org.alfresco.rest.RestTest; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestSiteMembershipRequestModel; +import org.alfresco.rest.model.RestSiteMembershipRequestModelsCollection; +import org.alfresco.rest.model.RestTaskModel; +import org.alfresco.utility.model.SiteModel; +import org.alfresco.utility.model.TestGroup; +import org.alfresco.utility.model.UserModel; +import org.alfresco.utility.report.Bug; +import org.alfresco.utility.testrail.ExecutionType; +import org.alfresco.utility.testrail.annotation.TestRail; +import org.springframework.http.HttpStatus; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +/** + * Created by Claudia Agache on 1/10/2017. + */ +public class GetSiteMembershipRequestsFullTests extends RestTest +{ + UserModel siteManager, newMember, adminUser, regularUser; + SiteModel moderatedSite1, moderatedSite2, publicSite, privateSite; + RestSiteMembershipRequestModelsCollection siteMembershipRequests; + + @BeforeClass(alwaysRun = true) + public void dataPreparation() throws Exception + { + siteManager = dataUser.createRandomTestUser(); + publicSite = dataSite.usingUser(siteManager).createPublicRandomSite(); + moderatedSite1 = dataSite.usingUser(siteManager).createModeratedRandomSite(); + moderatedSite2 = dataSite.usingUser(siteManager).createModeratedRandomSite(); + privateSite = dataSite.usingUser(siteManager).createPrivateRandomSite(); + + adminUser = dataUser.getAdminUser(); + newMember = dataUser.createRandomTestUser(); + regularUser = dataUser.createRandomTestUser(); + + restClient.authenticateUser(newMember).withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite1); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + restClient.withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite2); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + restClient.authenticateUser(adminUser).withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite1); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + restClient.withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite2); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify admin user gets all its own site membership requests with Rest API and response is successful (200)") + public void adminGetsItsOwnSiteMembershipRequestsWithSuccess() throws Exception + { + siteMembershipRequests = restClient.authenticateUser(adminUser).withCoreAPI().usingAuthUser().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListContains("id", moderatedSite1.getId()) + .assertThat().entriesListContains("id", moderatedSite2.getId()); + } + + @Bug(id = "MNT-16557") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify regular user fails to get all site membership requests of another user with Rest API (403)") + public void regularUserFailsToGetSiteMembershipRequestsOfAnotherUser() throws Exception + { + restClient.authenticateUser(regularUser).withCoreAPI() + .usingUser(newMember).getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Bug(id = "MNT-16557") + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify regular user fails to get all site membership requests of admin with Rest API (403)") + public void regularUserFailsToGetSiteMembershipRequestsOfAdmin() throws Exception + { + restClient.authenticateUser(regularUser).withCoreAPI() + .usingUser(adminUser).getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN) + .assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify regular user is able to get his site membership requests with, but skip the first one") + public void getSiteMembershipRequestsButSkipTheFirstOne() throws Exception + { + siteMembershipRequests = restClient.authenticateUser(newMember).withParams("orderBy=id ASC").withCoreAPI() + .usingMe().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListContains("id", moderatedSite1.getId()) + .assertThat().entriesListContains("id", moderatedSite2.getId()); + + RestSiteMembershipRequestModel firstSiteMembershipRequest = siteMembershipRequests.getEntries().get(0).onModel(); + + siteMembershipRequests = restClient.authenticateUser(newMember).withParams("orderBy=id ASC&skipCount=1").withCoreAPI() + .usingMe().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListDoesNotContain("id", firstSiteMembershipRequest.getId()) + .assertThat().entriesListContains("id", moderatedSite2.getId()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify regular user is able to get his site membership requests with higher skipCount than number of requests") + public void getSiteMembershipRequestsWithHighSkipCount() throws Exception + { + siteMembershipRequests = restClient.authenticateUser(newMember).withParams("skipCount=3").withCoreAPI() + .usingMe().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListIsEmpty(); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Verify get site membership requests returns an empty list where there are no requests") + public void getSiteMembershipRequestsWhereThereAreNoRequests() throws Exception + { + siteMembershipRequests = restClient.authenticateUser(regularUser).withCoreAPI().usingMe().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListIsEmpty(); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Reject request then get site membership requests.") + public void rejectRequestThenGetSiteMembershipRequests() throws Exception + { + UserModel userWithRejectedRequests = dataUser.createRandomTestUser(); + + restClient.authenticateUser(userWithRejectedRequests).withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite1); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + restClient.withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite2); + restClient.assertStatusCodeIs(HttpStatus.CREATED); + + RestTaskModel taskModel = restClient.authenticateUser(userWithRejectedRequests).withWorkflowAPI().getTasks().getTaskModelByDescription(moderatedSite1); + workflow.approveSiteMembershipRequest(siteManager.getUsername(), siteManager.getPassword(), taskModel.getId(), false, "Rejected"); + + siteMembershipRequests = restClient.authenticateUser(userWithRejectedRequests).withCoreAPI().usingMe().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListDoesNotContain("id", moderatedSite1.getId()) + .assertThat().entriesListContains("id", moderatedSite2.getId()); + } + + @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL }) + @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, + executionType = ExecutionType.REGRESSION, + description = "Check get site membership requests when properties parameter is used") + public void getSiteMembershipRequestsWithProperties() throws Exception + { + siteMembershipRequests = restClient.authenticateUser(newMember).withParams("properties=id") + .withCoreAPI().usingAuthUser().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListContains("id", moderatedSite1.getId()) + .assertThat().entriesListContains("id", moderatedSite2.getId()); + RestSiteMembershipRequestModel siteMembershipRequest = siteMembershipRequests.getOneRandomEntry().onModel(); + siteMembershipRequest.assertThat().fieldsCount().is(1); + } + +} diff --git a/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsSanityTests.java b/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsSanityTests.java index 34990bddd..1551fa7c3 100644 --- a/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsSanityTests.java @@ -1,8 +1,10 @@ package org.alfresco.rest.people; import org.alfresco.rest.RestTest; +import org.alfresco.rest.model.RestErrorModel; +import org.alfresco.rest.model.RestSiteMembershipRequestModelsCollection; import org.alfresco.utility.constants.UserRole; -import org.alfresco.utility.data.RandomData; +import org.alfresco.utility.data.DataUser; import org.alfresco.utility.model.SiteModel; import org.alfresco.utility.model.TestGroup; import org.alfresco.utility.model.UserModel; @@ -10,7 +12,6 @@ import org.alfresco.utility.report.Bug; import org.alfresco.utility.testrail.ExecutionType; import org.alfresco.utility.testrail.annotation.TestRail; import org.springframework.http.HttpStatus; -import org.springframework.social.alfresco.api.entities.Site.Visibility; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; @@ -22,21 +23,21 @@ import org.testng.annotations.Test; public class GetSiteMembershipRequestsSanityTests extends RestTest { - UserModel userModel; - SiteModel siteModel; - UserModel newMember; + UserModel siteManager, newMember; + DataUser.ListUserWithRoles usersWithRoles; + SiteModel moderatedSite; + RestSiteMembershipRequestModelsCollection siteMembershipRequests; @BeforeClass(alwaysRun = true) public void dataPreparation() throws Exception { - userModel = dataUser.createRandomTestUser(); - String siteId = RandomData.getRandomName("site"); - siteModel = dataSite.usingUser(userModel).createSite(new SiteModel(Visibility.MODERATED, siteId, siteId, siteId, siteId)); + siteManager = dataUser.createRandomTestUser(); + moderatedSite = dataSite.usingUser(siteManager).createModeratedRandomSite(); newMember = dataUser.createRandomTestUser(); - - restClient.authenticateUser(newMember).withCoreAPI().usingAuthUser().addSiteMembershipRequest(siteModel); - + restClient.authenticateUser(newMember).withCoreAPI().usingAuthUser().addSiteMembershipRequest(moderatedSite); restClient.assertStatusCodeIs(HttpStatus.CREATED); + usersWithRoles = dataUser.addUsersWithRolesToSite(moderatedSite, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer, + UserRole.SiteContributor); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) @@ -44,11 +45,10 @@ public class GetSiteMembershipRequestsSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user gets all site membership requests of a specific person with Rest API and response is successful (200)") public void managerUserGetsSiteMembershipRequestsWithSuccess() throws Exception { - UserModel managerUser = dataUser.usingAdmin().createRandomTestUser(); - dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel, UserRole.SiteManager); - - restClient.authenticateUser(managerUser).withCoreAPI().usingUser(newMember).getSiteMembershipRequests().assertThat().entriesListIsNotEmpty(); + siteMembershipRequests = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager)).withCoreAPI() + .usingUser(newMember).getSiteMembershipRequests(); restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListIsNotEmpty(); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) @@ -56,10 +56,8 @@ public class GetSiteMembershipRequestsSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify collaborator user fails to get all site membership requests of another user with Rest API (403)") public void collaboratorUserFailsToGetSiteMembershipRequestsOfAnotherUser() throws Exception { - UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser(); - dataUser.usingUser(userModel).addUserToSite(collaboratorUser, siteModel, UserRole.SiteCollaborator); - - restClient.authenticateUser(collaboratorUser).withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).withCoreAPI() + .usingUser(newMember).getSiteMembershipRequests(); restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); } @@ -68,10 +66,8 @@ public class GetSiteMembershipRequestsSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify contributor user fails to get all site membership requests of another user with Rest API (403)") public void contributorUserFailsToGetSiteMembershipRequestsOfAnotherUser() throws Exception { - UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser(); - dataUser.usingUser(userModel).addUserToSite(contributorUser, siteModel, UserRole.SiteContributor); - - restClient.authenticateUser(contributorUser).withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor)).withCoreAPI() + .usingUser(newMember).getSiteMembershipRequests(); restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); } @@ -80,10 +76,7 @@ public class GetSiteMembershipRequestsSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify consumer user fails to get all site membership requests of another user with Rest API (403)") public void consumerUserFailsToGetSiteMembershipRequestsOfAnotherUser() throws Exception { - UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser(); - dataUser.usingUser(userModel).addUserToSite(consumerUser, siteModel, UserRole.SiteConsumer); - - restClient.authenticateUser(consumerUser).withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); + restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN); } @@ -92,29 +85,37 @@ public class GetSiteMembershipRequestsSanityTests extends RestTest @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify admin user gets all site membership requests of a specific person with Rest API and response is successful (200)") public void adminUserGetsSiteMembershipRequestsWithSuccess() throws Exception { - UserModel adminUser = dataUser.getAdminUser(); - - restClient.authenticateUser(adminUser).withCoreAPI().usingUser(newMember).getSiteMembershipRequests().assertThat().entriesListIsNotEmpty(); + siteMembershipRequests = restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI() + .usingUser(newMember).getSiteMembershipRequests(); restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListIsNotEmpty(); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) @Bug(id = "MNT-16904") @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user fails to get all site membership requests of a specific person with Rest API when the authentication fails (401)") - public void managerUserNotAuthorizedFailsToGetSiteMembershipRequests() throws Exception + public void unauthorizedUserFailsToGetSiteMembershipRequests() throws Exception { - UserModel managerUser = dataUser.usingAdmin().createRandomTestUser(); - dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel, UserRole.SiteManager); - managerUser.setPassword("newpassword"); - restClient.authenticateUser(managerUser).withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); - restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED); + restClient.authenticateUser(new UserModel("random user", "random password")).withCoreAPI() + .usingAuthUser().getSiteMembershipRequests(); + restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED) + .assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED); } @Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY }) @TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify a user gets all its own site membership requests with Rest API and response is successful (200)") public void oneUserGetsItsOwnSiteMembershipRequestsWithSuccess() throws Exception { - restClient.authenticateUser(newMember).withCoreAPI().usingUser(newMember).getSiteMembershipRequests().assertThat().entriesListIsNotEmpty(); + siteMembershipRequests = restClient.authenticateUser(newMember).withCoreAPI().usingUser(newMember).getSiteMembershipRequests(); restClient.assertStatusCodeIs(HttpStatus.OK); + siteMembershipRequests.assertThat().entriesListContains("id", moderatedSite.getId()) + .assertThat().entriesListContains("message", "Please accept me") + .assertThat().entriesListCountIs(1); + siteMembershipRequests.getEntries().get(0).onModel().getSite() + .assertThat().field("visibility").is(moderatedSite.getVisibility()) + .assertThat().field("guid").is(moderatedSite.getGuid()) + .assertThat().field("description").is(moderatedSite.getDescription()) + .assertThat().field("id").is(moderatedSite.getId()) + .assertThat().field("title").is(moderatedSite.getTitle()); } } diff --git a/e2e-test/java/org/alfresco/rest/workflow/deployments/GetDeploymentsSanityTests.java b/e2e-test/java/org/alfresco/rest/workflow/deployments/GetDeploymentsSanityTests.java index df66b5e57..407689b74 100644 --- a/e2e-test/java/org/alfresco/rest/workflow/deployments/GetDeploymentsSanityTests.java +++ b/e2e-test/java/org/alfresco/rest/workflow/deployments/GetDeploymentsSanityTests.java @@ -27,8 +27,7 @@ public class GetDeploymentsSanityTests extends RestTest restClient.authenticateUser(adminUserModel); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.DEPLOYMENTS }, executionType = ExecutionType.SANITY, + @TestRail(section = { TestGroup.REST_API, TestGroup.WORKFLOW, TestGroup.DEPLOYMENTS }, executionType = ExecutionType.SANITY, description = "Verify Admin user gets non-network deployments using REST API and status code is OK (200)") @Test(groups = { TestGroup.REST_API, TestGroup.WORKFLOW, TestGroup.DEPLOYMENTS, TestGroup.SANITY}) public void getNonNetworkDeploymentsWithAdmin() throws JsonToModelConversionException, Exception @@ -38,8 +37,7 @@ public class GetDeploymentsSanityTests extends RestTest deployments.assertThat().entriesListIsNotEmpty(); } - @TestRail(section = { TestGroup.REST_API, - TestGroup.DEPLOYMENTS }, executionType = ExecutionType.SANITY, + @TestRail(section = { TestGroup.REST_API, TestGroup.WORKFLOW, TestGroup.DEPLOYMENTS }, executionType = ExecutionType.SANITY, description = "Verify Tenant Admin user gets network deployments using REST API and status code is OK (200)") @Test(groups = { TestGroup.REST_API, TestGroup.WORKFLOW, TestGroup.DEPLOYMENTS, TestGroup.SANITY, TestGroup.NETWORKS}) public void getNetworkDeploymentsWithAdmin() throws JsonToModelConversionException, Exception diff --git a/e2e-test/resources/default.properties b/e2e-test/resources/default.properties index f5733caf1..6d12861d7 100644 --- a/e2e-test/resources/default.properties +++ b/e2e-test/resources/default.properties @@ -3,6 +3,10 @@ alfresco.scheme=http alfresco.server=localhost alfresco.port=8080 +# in containers we cannot access directly JMX, so we will use http://jolokia.org agent +# disabling this we will use direct JMX calls to server +jmx.useJolokiaAgent=false + # credentials admin.user=admin admin.password=admin @@ -34,10 +38,6 @@ testManagement.suiteId=12 # The location of the reports path reports.path=./target/reports -# in containers we cannot access directly JMX, so we will use http://jolokia.org agent -# disabling this we will use direct JMX calls to server -jmx.useJolokiaAgent=true - # # Database Section # You should provide here the database URL, that can be a differed server as alfresco. diff --git a/e2e-test/resources/log4j.properties b/e2e-test/resources/log4j.properties index 63d3970dc..00e9b5a11 100644 --- a/e2e-test/resources/log4j.properties +++ b/e2e-test/resources/log4j.properties @@ -6,10 +6,21 @@ log4j.appender.file=org.apache.log4j.RollingFileAppender log4j.appender.file.File=./target/reports/alfresco-tas.log log4j.appender.file.MaxBackupIndex=10 log4j.appender.file.layout=org.apache.log4j.PatternLayout -log4j.appender.file.layout.ConversionPattern=%d{HH:mm:ss} %-5p %c{1}:%L - %m%n +log4j.appender.file.layout.ConversionPattern=[%t] %d{HH:mm:ss} %-5p %c{1}:%L - %m%n # Direct log messages to stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.out log4j.appender.stdout.layout=org.apache.log4j.PatternLayout -log4j.appender.stdout.layout.ConversionPattern=%d{HH:mm:ss} %-5p %c{1}:%L - %m%n \ No newline at end of file +log4j.appender.stdout.layout.ConversionPattern=[%t] %d{HH:mm:ss} %-5p %c{1}:%L - %m%n + +# TestRail particular log file +# Direct log messages to a log file +log4j.appender.testrailLog=org.apache.log4j.RollingFileAppender +log4j.appender.testrailLog.File=./target/reports/alfresco-testrail.log +log4j.appender.testrailLog.MaxBackupIndex=10 +log4j.appender.testrailLog.layout=org.apache.log4j.PatternLayout +log4j.appender.testrailLog.layout.ConversionPattern=%d{HH:mm:ss} %-5p %c{1}:%L - %m%n + +log4j.category.testrail=INFO, testrailLog +log4j.additivity.testrail=false \ No newline at end of file