inteligr8/SearchServices
1
0
Fork 0
mirror of https://github.com/Alfresco/SearchServices.git synced 2026-09-16 18:12:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into getCommentsFullTests

Browse Source
This commit is contained in:
Valentin Popa
2017-01-11 18:29:53 +02:00
parent 8977512310 24bf9f1fc1
commit 363c3c7212
36 changed files with 2697 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files
e2e-test/java/org/alfresco/rest/comments/AddCommentsFullTests.java
+162
View File
@@ -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");
}
}
e2e-test/java/org/alfresco/rest/comments/AddCommentsSanityTests.java
+1 -2
View File
@@ -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);
}
e2e-test/java/org/alfresco/rest/comments/GetCommentsSanityTests.java
+10 -9
View File
@@ -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
e2e-test/java/org/alfresco/rest/favorites/AddFavoritesCoreTests.java
+1 -2
View File
@@ -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);
e2e-test/java/org/alfresco/rest/favorites/AddFavoritesSanityTests.java
+1 -3
View File
@@ -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);
}
e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteCoreTests.java
+174
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteFullTests.java
+246
View File
@@ -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());
}
}
e2e-test/java/org/alfresco/rest/favorites/DeleteFavoritesSanityTests.java → e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteSanityTests.java
+171 -146
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteCoreTests.java
+29 -3
View File
@@ -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());
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteFullTests.java
+84 -20
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSanityTests.java
+3 -8
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoritesCoreTests.java
-4
View File
@@ -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);
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoritesFullTests.java
+230
View File
@@ -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 <personid> 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());
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoritesSanityTests.java
+3 -5
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestFullTests.java
+25
View File
@@ -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")
e2e-test/java/org/alfresco/rest/people/AddSiteMembershipRequestSanityTests.java
-1
View File
@@ -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;
e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteCoreTests.java
+23 -10
View File
@@ -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();
e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteFullTests.java
+185
View File
@@ -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());
}
}
e2e-test/java/org/alfresco/rest/people/DeleteFavoriteSiteSanityTests.java
+59 -10
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/people/GetFavoriteSiteFullTests.java
+163
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesCoreTests.java
+126
View File
@@ -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());
}
}
e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesFullTests.java
+224
View File
@@ -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<RestActivitySummaryModel> allActivitySummary = new ArrayList<RestActivitySummaryModel>();
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<RestActivitySummaryModel> 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());
}
}
e2e-test/java/org/alfresco/rest/people/GetPeopleActivitiesSanityTests.java
+4
View File
@@ -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 })
e2e-test/java/org/alfresco/rest/people/GetPeopleCoreTests.java
-1
View File
@@ -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;
e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceCoreTests.java
+5 -5
View File
@@ -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())));
}
}
e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceFullTests.java
+222
View File
@@ -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 <personid> 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);
}
}
e2e-test/java/org/alfresco/rest/people/GetPeoplePreferenceSanityTests.java
+11 -11
View File
@@ -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());
}
}
e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesCoreTests.java
+123
View File
@@ -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()));
}
}
e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesFullTests.java
+130
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/people/GetPeoplePreferencesSanityTests.java
+5 -5
View File
@@ -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 })
e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsCoreTests.java
+50 -21
View File
@@ -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 <personid> for request.")
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE },
executionType = ExecutionType.REGRESSION,
description = "Specify -me- string in place of <personid> 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
{
e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsFullTests.java
+170
View File
@@ -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);
}
}
e2e-test/java/org/alfresco/rest/people/GetSiteMembershipRequestsSanityTests.java
+38 -37
View File
@@ -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());
}
}
e2e-test/java/org/alfresco/rest/workflow/deployments/GetDeploymentsSanityTests.java
+2 -4
View File
@@ -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