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

REPO-2755 / REPO-2251: changed CORE and FULL groups with REGRESSION in favorites package

Browse Source
This commit is contained in:
cagache
2017-10-06 11:59:47 +03:00
parent 65887702fe
commit 9d1c12a7f1
27 changed files with 2969 additions and 3565 deletions
Download Patch File Download Diff File Expand all files Collapse all files
e2e-test/java/org/alfresco/rest/favorites/AddFavoriteSiteTests.java
+29 -29
View File
@@ -67,7 +67,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify collaborator user add a favorite site with Rest API and response is successful (201)")
public void collaboratorUserAddFavoriteSiteWithSuccess() throws Exception
{
@@ -79,7 +79,7 @@ public class AddFavoriteSiteTests extends RestTest
restFavoriteSiteModel.assertThat().field("id").is(publicSite.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify contributor user add a favorite site with Rest API and response is successful (201)")
public void contributorUserAddFavoriteSiteWithSuccess() throws Exception
{
@@ -91,7 +91,7 @@ public class AddFavoriteSiteTests extends RestTest
restFavoriteSiteModel.assertThat().field("id").is(publicSite.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify consumer user add a favorite site with Rest API and response is successful (201)")
public void consumerUserAddFavoriteSiteWithSuccess() throws Exception
{
@@ -103,7 +103,7 @@ public class AddFavoriteSiteTests extends RestTest
restFavoriteSiteModel.assertThat().field("id").is(publicSite.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify admin user add a favorite site with Rest API and response is successful (201)")
public void adminUserAddFavoriteSiteWithSuccess() throws Exception
{
@@ -112,7 +112,7 @@ public class AddFavoriteSiteTests extends RestTest
restFavoriteSiteModel.assertThat().field("id").is(publicSite.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify manager user is not able to add a favorite site when the site is already favorite - status code (409)")
public void managerUserAddFavoriteSiteAlreadyAFavoriteSite() throws Exception
@@ -133,7 +133,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsErrorKey(String.format("Site %s is already a favourite site", publicSite.getId()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify user doesn't have permission to delete favorites of admin user with Rest API and status code is 403")
public void userIsNotAbleToAddFavoriteSiteOfAnotherUser() throws Exception
@@ -151,7 +151,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify manager user is able to add as favorite a private site.")
public void managerAddsPrivateSiteAsFavorite() throws Exception
@@ -173,7 +173,7 @@ public class AddFavoriteSiteTests extends RestTest
.and().field("title").is(privateSite.getTitle());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify manager user is able to add as favorite a moderated site.")
public void managerAddsModeratedSiteAsFavorite() throws Exception
@@ -195,7 +195,7 @@ public class AddFavoriteSiteTests extends RestTest
.and().field("title").is(moderatedSite.getTitle());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@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 (201)")
public void addFavoriteSiteWithSuccessUsingMeAsPersonId() throws Exception
@@ -204,7 +204,7 @@ public class AddFavoriteSiteTests extends RestTest
restClient.assertStatusCodeIs(HttpStatus.CREATED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@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
@@ -221,7 +221,7 @@ public class AddFavoriteSiteTests extends RestTest
}
@Bug(id="ACE-2413")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify empty user is not able to add a site from favorites and response is (400)")
public void emptyUserIsNotAbleToRemoveFavoriteSite() throws Exception
@@ -233,7 +233,7 @@ public class AddFavoriteSiteTests extends RestTest
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "emptyUser"));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify inexistent user is not able to add a site from favorites and response is (404)")
public void inexistentUserIsNotAbleToRemoveFavoriteSite() throws Exception
@@ -250,7 +250,7 @@ public class AddFavoriteSiteTests extends RestTest
}
@Bug(id="REPO-1827")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify user is not able to add a favorite site when the 'id' is empty - status code (400)")
public void userAddFavoriteSiteWithEmptySiteId() throws Exception
@@ -266,7 +266,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify admin user doesn't have permission to add a favorite site of another user with Rest API and status code is 403")
public void adminIsNotAbleToAddFavoriteSiteOfAnotherUser() throws Exception
@@ -282,7 +282,7 @@ public class AddFavoriteSiteTests extends RestTest
}
@Bug(id="MNT-17338")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify admin user doesn't have permission to add a favorite site of another user with Rest API and status code is 403")
public void userIsNotAbleToAddFavoriteSiteOfAdmin() throws Exception
@@ -297,7 +297,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify add favorite site using empty body - status code is 400")
public void addFavoriteSiteWithEmptyBody() throws Exception
@@ -312,7 +312,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsSummary(String.format(RestErrorModel.NO_CONTENT, "Unrecognized field " + "\"ids\""));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify add favorite site using empty body - status code is 400")
public void addFavoriteSiteWithEmptyRequiredFieldsBody() throws Exception
@@ -327,7 +327,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsSummary(String.format(RestErrorModel.NO_CONTENT, "Unrecognized field " + "\"\""));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify non member user is not able to add a private favorite site - status code is 404")
public void userAddFavoriteSiteUserNotMemberOfPrivateSite() throws Exception
@@ -344,7 +344,7 @@ public class AddFavoriteSiteTests extends RestTest
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify non member user is able to add a moderated favorite site")
public void userAddFavoriteSiteUserNotMemberOfModeratedSite() throws Exception
@@ -364,7 +364,7 @@ public class AddFavoriteSiteTests extends RestTest
.and().field("title").is(moderatedSite.getTitle());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify non member user is able to add a public favorite site")
public void userAddFavoriteSiteUserNotMemberOfPublicSite() throws Exception
@@ -385,7 +385,7 @@ public class AddFavoriteSiteTests extends RestTest
.and().field("title").is(publicSite.getTitle());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Check that if id does not exist, status code is 404")
public void addFavoriteSiteUsingInvalidId() throws Exception
@@ -401,7 +401,7 @@ public class AddFavoriteSiteTests extends RestTest
publicSite.setId(id);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides site in id but id is of a file status code is 404")
public void addSiteToFavoritesUsingFileId() throws Exception
@@ -415,7 +415,7 @@ public class AddFavoriteSiteTests extends RestTest
publicSite.setId(id);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides site in id but id is of a folder status code is 404")
public void addSiteToFavoritesUsingFolderId() throws Exception
@@ -430,7 +430,7 @@ public class AddFavoriteSiteTests extends RestTest
publicSite.setId(id);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides site in id but id is of a comment status code is 404")
public void addSiteToFavoriteUsingCommentId() throws Exception
@@ -447,7 +447,7 @@ public class AddFavoriteSiteTests extends RestTest
publicSite.setId(id);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides site in id but id is of a tag status code is 404")
public void addSiteFavoriteUsingTagId() throws Exception
@@ -462,7 +462,7 @@ public class AddFavoriteSiteTests extends RestTest
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, returnedModel.getId()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if id does not describe a site, file, or folder status code is 400")
public void addFavoriteUsingInvalidGuid() throws Exception
@@ -477,7 +477,7 @@ public class AddFavoriteSiteTests extends RestTest
}
@Bug(id="MNT-16904")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE,TestGroup.NETWORKS, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.NETWORKS, TestGroup.REGRESSION})
@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 - status code (401)")
public void tenantIsNotAbleToDeleteFavoriteSiteWithInvalidNetworkID() throws Exception
@@ -499,7 +499,7 @@ public class AddFavoriteSiteTests extends RestTest
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE,TestGroup.NETWORKS, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.NETWORKS, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE}, executionType = ExecutionType.REGRESSION,
description = "Verify tenant user is able to add to favorites his site and status code is (201)")
public void tenantAddFavoriteSiteValidNetwork() throws Exception
@@ -521,7 +521,7 @@ public class AddFavoriteSiteTests extends RestTest
.entriesListContains("targetGuid", publicSite.getGuidWithoutVersion());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE,TestGroup.NETWORKS, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.NETWORKS, TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE}, executionType = ExecutionType.REGRESSION,
description = "Verify tenant user is able to add to favorites a site created by admin tenant - same network and status code is (201)")
public void tenantUserIsAbleToAddFavoriteSiteAddedByAdminSameNetwork() throws Exception
e2e-test/java/org/alfresco/rest/favorites/AddFavoritesTests.java
+272 -318
View File
@@ -37,18 +37,6 @@ public class AddFavoritesTests extends RestTest
folder = dataContent.usingSite(siteModel).usingUser(adminUserModel).createFolder();
}
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES },
executionType = ExecutionType.SANITY,
description = "Verify Manager user add site to favorites with Rest API and status code is 201")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToAddToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager)).withCoreAPI()
.usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
// @Bug(id="MNT-16904", description = "It fails only on environment with tenants")
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets status code 401 if authentication call fails")
@@ -64,7 +52,7 @@ public class AddFavoritesTests extends RestTest
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Collaborator user add site to favorites with Rest API and status code is 201")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToAddToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
@@ -75,7 +63,7 @@ public class AddFavoritesTests extends RestTest
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Contributor user add site to favorites with Rest API and status code is 201")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToAddToFavorites() throws JsonToModelConversionException, Exception
{
restPersonFavoritesModel= restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
@@ -86,7 +74,7 @@ public class AddFavoritesTests extends RestTest
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Consumer user add site to favorites with Rest API and status code is 201")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToAddToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
@@ -97,7 +85,7 @@ public class AddFavoritesTests extends RestTest
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Admin user add site to favorites with Rest API and status code is 201")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToAddToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
@@ -108,7 +96,7 @@ public class AddFavoritesTests extends RestTest
@Bug(id = "MNT-17157")
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if a favorite already exists with the specified id status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFavoriteTwice() throws Exception
{
SiteModel site = dataSite.usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager)).createPublicRandomSite();
@@ -118,304 +106,43 @@ public class AddFavoritesTests extends RestTest
restClient.assertStatusCodeIs(HttpStatus.CONFLICT);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Add to favorites a file for a Manager, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToAddFileToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
RestFileModel restFileModel = restPersonFavoritesModel.getTarget().getFile();
restFileModel.assertThat().field("mimeType").is("text/plain").and()
.field("isFile").is("true").and()
.field("isFolder").is("false").and()
.field("createdBy").is(adminUserModel.getUsername());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Add to favorites a folder for a Manager, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToAddFolderToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager))
.withCoreAPI().usingAuthUser().addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRefWithoutVersion());
RestFolderModel restFolderModel = restPersonFavoritesModel.getTarget().getFolder();
restFolderModel.assertThat().field("isFile").is("false").and()
.field("isFolder").is("true").and()
.field("createdBy").is(adminUserModel.getUsername());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Add to favorites a site for a Manager, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToAddSiteToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify add favorite specifying -me- string in place of <personid> for request")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToAddFavoriteWhenUsingMeAsUsername() throws Exception
{
UserModel user = dataUser.createRandomTestUser();
restPersonFavoritesModel = restClient.authenticateUser(user)
.withCoreAPI().usingMe().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
restClient.authenticateUser(user).withCoreAPI().usingAuthUser().getFavoriteSites().assertThat().entriesListContains("guid", siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a file for a Collaborator, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void collaboratorIsAbleToAddFileToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a file for a Contributor, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void contributorIsAbleToAddFileToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a file for a Consumer, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void consumerIsAbleToAddFileToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a folder for a Collaborator, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void collaboratorIsAbleToAddFolderToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a folder for a Contributor, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void contributorIsAbleToAddFolderToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a folder for a Consumer, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void consumerIsAbleToAddFolderToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a site for a Collaborator, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void collaboratorIsAbleToAddSiteToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a site for a Contributor, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void contributorIsAbleToAddSiteToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a site for a Consumer, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void consumerIsAbleToAddSiteToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if target guid does not describe a site, file, or folder status code is 400")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFavoriteUsingInvalidGuid() throws Exception
{
LinkModel link = dataLink.usingAdmin().usingSite(siteModel).createRandomLink();
SiteModel site = dataSite.usingUser(adminUserModel).createPublicRandomSite();
site.setGuid(link.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(site);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, site.getGuid().split("/")[3]));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if personId does not exist, status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFavoriteUsingInexistentUser() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(new UserModel("random_user", "random_password")).addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "random_user"));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if target guid does not exist, status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFavoriteUsingInexistentGuid() throws Exception
{
SiteModel site = dataSite.usingUser(adminUserModel).createPublicRandomSite();
site.setGuid("random_guid");
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(site);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "random_guid"));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides file in target but guid is of a folder status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFileToFavoritesUsingFolderGuid() throws Exception
{
String nodeRef = document.getNodeRef();
document.setNodeRef(folder.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND,
adminUserModel.getUsername(), folder.getNodeRefWithoutVersion()));
document.setNodeRef(nodeRef);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify add favorite, perform getFavorites call, check value is updated")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void verifyGetFavoritesAfterFavoritingSite() throws Exception
{
UserModel user = dataUser.createRandomTestUser();
restPersonFavoritesModel = restClient.authenticateUser(user)
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restClient.authenticateUser(user).withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListContains("guid", siteModel.getGuid());
}
// @Bug(id = "MNT-17158", description="Not a bug, If we need to stop comments from being favorited then an improvement/enhancement request should be raised against the platform.")
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify add file favorite with comment id returns status code 201")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFileFavoriteUsingCommentId() throws Exception
{
FileModel file = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(CMISUtil.DocumentType.TEXT_PLAIN);
RestCommentModel comment = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(file).addComment("This is a comment");
file.setNodeRef(comment.getId());
restPersonFavoritesModel = restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(file);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(file.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify add file favorite with tag id returns status code 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFileFavoriteUsingTagId() throws Exception
{
FileModel file = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(CMISUtil.DocumentType.TEXT_PLAIN);
RestTagModel returnedModel = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(file).addTag("random_tag");
file.setNodeRef(returnedModel.getId());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(file);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND,
adminUserModel.getUsername(), returnedModel.getId()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides site in target but id is of a file status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addSiteToFavoritesUsingFileId() throws Exception
{
String guid = siteModel.getGuid();
siteModel.setGuid(document.getNodeRefWithoutVersion());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, document.getNodeRefWithoutVersion()));
siteModel.setGuid(guid);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides folder in target but guid is of a file status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFolderToFavoritesUsingFileGuid() throws Exception
{
String nodeRef = folder.getNodeRef();
folder.setNodeRef(document.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, document.getNodeRef()));
folder.setNodeRef(nodeRef);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides file in target but guid is of a site status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addSiteToFavoritesUsingFolderId() throws Exception
{
SiteModel newSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
newSiteModel.setGuid(folder.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(newSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, folder.getNodeRef()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides folder in target but guid is of a site status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void addFolderToFavoritesUsingSiteId() throws Exception
{
FolderModel newFolder = dataContent.usingSite(siteModel).usingUser(adminUserModel).createFolder();
newFolder.setNodeRef(siteModel.getGuid());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFolderToFavorites(newFolder);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND,
adminUserModel.getUsername(), siteModel.getGuid()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify the response of favorite a site call is valid")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void verifyFavoriteASiteResponseIsValid() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
@@ -431,42 +158,269 @@ public class AddFavoritesTests extends RestTest
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify the response of favorite a file call is valid")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void verifyFavoriteAFileResponseIsValid() throws Exception
description = "Verify add favorite specifying -me- string in place of <personid> for request")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToAddFavoriteWhenUsingMeAsUsername() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
UserModel user = dataUser.createRandomTestUser();
restPersonFavoritesModel = restClient.authenticateUser(user)
.withCoreAPI().usingMe().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
RestFileModel restFileModel = restPersonFavoritesModel.getTarget().getFile();
restFileModel.assertThat().field("mimeType").is("text/plain").and()
.field("isFile").is("true").and()
.field("isFolder").is("false").and()
.field("createdBy").is(adminUserModel.getUsername());
restClient.authenticateUser(user).withCoreAPI().usingAuthUser().getFavoriteSites().assertThat().entriesListContains("guid", siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify the response of favorite a folder call is valid")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void verifyFavoriteAFolderResponseIsValid() throws Exception
description = "Add to favorites a file for a Collaborator, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToAddFileToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager))
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a file for a Contributor, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToAddFileToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a file for a Consumer, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToAddFileToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(document.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a folder for a Collaborator, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToAddFolderToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a folder for a Contributor, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToAddFolderToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRef());
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRefWithoutVersion());
}
RestFolderModel restFolderModel = restPersonFavoritesModel.getTarget().getFolder();
restFolderModel.assertThat().field("isFile").is("false").and()
.field("isFolder").is("true").and()
.field("createdBy").is(adminUserModel.getUsername());
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a folder for a Consumer, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToAddFolderToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(folder.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a site for a Collaborator, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToAddSiteToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a site for a Contributor, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToAddSiteToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Add to favorites a site for a Consumer, check it was added")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToAddSiteToFavorites() throws Exception
{
restPersonFavoritesModel = restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API,TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if target guid does not describe a site, file, or folder status code is 400")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFavoriteUsingInvalidGuid() throws Exception
{
LinkModel link = dataLink.usingAdmin().usingSite(siteModel).createRandomLink();
SiteModel site = dataSite.usingUser(adminUserModel).createPublicRandomSite();
site.setGuid(link.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(site);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, site.getGuid().split("/")[3]));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if personId does not exist, status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFavoriteUsingInexistentUser() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(new UserModel("random_user", "random_password")).addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "random_user"));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if target guid does not exist, status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFavoriteUsingInexistentGuid() throws Exception
{
SiteModel site = dataSite.usingUser(adminUserModel).createPublicRandomSite();
site.setGuid("random_guid");
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(site);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "random_guid"));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides file in target but guid is of a folder status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFileToFavoritesUsingFolderGuid() throws Exception
{
String nodeRef = document.getNodeRef();
document.setNodeRef(folder.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(document);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND,
adminUserModel.getUsername(), folder.getNodeRefWithoutVersion()));
document.setNodeRef(nodeRef);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify add favorite, perform getFavorites call, check value is updated")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void verifyGetFavoritesAfterFavoritingSite() throws Exception
{
UserModel user = dataUser.createRandomTestUser();
restPersonFavoritesModel = restClient.authenticateUser(user)
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restClient.authenticateUser(user).withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListContains("guid", siteModel.getGuid());
}
// @Bug(id = "MNT-17158", description="Not a bug, If we need to stop comments from being favorited then an improvement/enhancement request should be raised against the platform.")
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify add file favorite with comment id returns status code 201")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFileFavoriteUsingCommentId() throws Exception
{
FileModel file = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(CMISUtil.DocumentType.TEXT_PLAIN);
RestCommentModel comment = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(file).addComment("This is a comment");
file.setNodeRef(comment.getId());
restPersonFavoritesModel = restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(file);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restPersonFavoritesModel.assertThat().field("targetGuid").is(file.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify add file favorite with tag id returns status code 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFileFavoriteUsingTagId() throws Exception
{
FileModel file = dataContent.usingSite(siteModel).usingUser(adminUserModel).createContent(CMISUtil.DocumentType.TEXT_PLAIN);
RestTagModel returnedModel = restClient.authenticateUser(adminUserModel).withCoreAPI().usingResource(file).addTag("random_tag");
file.setNodeRef(returnedModel.getId());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFileToFavorites(file);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND,
adminUserModel.getUsername(), returnedModel.getId()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides site in target but id is of a file status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addSiteToFavoritesUsingFileId() throws Exception
{
String guid = siteModel.getGuid();
siteModel.setGuid(document.getNodeRefWithoutVersion());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, document.getNodeRefWithoutVersion()));
siteModel.setGuid(guid);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides folder in target but guid is of a file status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFolderToFavoritesUsingFileGuid() throws Exception
{
String nodeRef = folder.getNodeRef();
folder.setNodeRef(document.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFolderToFavorites(folder);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, document.getNodeRef()));
folder.setNodeRef(nodeRef);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides file in target but guid is of a site status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addSiteToFavoritesUsingFolderId() throws Exception
{
SiteModel newSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
newSiteModel.setGuid(folder.getNodeRef());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addSiteToFavorites(newSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, folder.getNodeRef()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user provides folder in target but guid is of a site status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void addFolderToFavoritesUsingSiteId() throws Exception
{
FolderModel newFolder = dataContent.usingSite(siteModel).usingUser(adminUserModel).createFolder();
newFolder.setNodeRef(siteModel.getGuid());
restClient.authenticateUser(adminUserModel).withCoreAPI().usingAuthUser().addFolderToFavorites(newFolder);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND,
adminUserModel.getUsername(), siteModel.getGuid()));
}
@Bug(id = "REPO-1061")
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Check that if user does not have permission to favorite a site status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void verifyFavoriteASiteIfTheUserDoesNotHavePermission() throws Exception
{
SiteModel privateSite = dataSite.usingUser(adminUserModel).createPrivateRandomSite();
@@ -481,7 +435,7 @@ public class AddFavoritesTests extends RestTest
@Bug(id = "MNT-16904")
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify the post favorites request when network id is invalid for tenant user")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL, TestGroup.NETWORKS})
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION, TestGroup.NETWORKS})
public void addFavoriteSitesWhenNetworkIdIsInvalid() throws JsonToModelConversionException, Exception
{
UserModel adminTenantUser = UserModel.getAdminTenantUser();
@@ -497,7 +451,7 @@ public class AddFavoritesTests extends RestTest
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify the response of favorite a sie with empty body at request")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void verifyFavoriteASiteWithEmptyBody() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI();
e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteCoreTests.java
-171
View File
@@ -1,171 +0,0 @@
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
@@ -1,246 +0,0 @@
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 }, 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}, 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}, 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/DeleteFavoriteSanityTests.java
-172
View File
@@ -1,172 +0,0 @@
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", description = "It fails only on environment with tenants")
@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).assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
}
e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteSiteCoreTests.java
-158
View File
@@ -1,158 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.rest.model.RestSiteModel;
import org.alfresco.utility.constants.UserRole;
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;
public class DeleteFavoriteSiteCoreTests extends RestTest
{
UserModel userModel;
SiteModel siteModel;
UserModel adminUserModel;
RestSiteModel restSiteModel;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
siteModel = dataSite.usingUser(userModel).createPublicRandomSite();
adminUserModel = dataUser.getAdminUser();
}
@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)")
public void removeFavoriteSiteWithSuccessUsingMeAsPersonId() throws Exception
{
restClient.authenticateUser(adminUserModel);
dataSite.usingUser(adminUserModel).usingSite(siteModel).addSiteToFavorites();
restClient.withCoreAPI().usingMe().removeFavoriteSite(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
}
@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")
public void inexistentUserIsNotAbleToRemoveFavoriteSite() throws Exception
{
UserModel inexistentUser = new UserModel("inexistenUser", "password");
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(inexistentUser)
.removeFavoriteSite(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "inexistenUser"));
}
@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")
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()))
.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)")
public void managerUserRemovesFavoriteSiteAndAddItAgain() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser()
.removeFavoriteSite(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingUser(managerUser).addFavoriteSite(siteModel);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
}
@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)")
public void managerUserRemovesFavoriteSiteWithSuccess() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser()
.removeFavoriteSite(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingAuthUser().getFavorites()
.assertThat().entriesListDoesNotContain("id", siteModel.getId());
}
@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")
public void uninvitedUserCanDeleteFavoritePublicSite() throws Exception
{
SiteModel publicSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).addFavoriteSite(publicSiteModel);
restClient.withCoreAPI().usingAuthUser()
.removeFavoriteSite(publicSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListDoesNotContain("id", publicSiteModel.getId());
}
@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")
public void uninvitedUserCanDeleteFavoriteModeratedSite() throws Exception
{
SiteModel moderatedSiteModel = dataSite.usingUser(adminUserModel).createModeratedRandomSite();
restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).addFavoriteSite(moderatedSiteModel);
restClient.withCoreAPI().usingAuthUser()
.removeFavoriteSite(moderatedSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListDoesNotContain("id", moderatedSiteModel.getId());
}
@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")
public void userCanDeleteFavoritePrivateSite() throws Exception
{
SiteModel privateSiteModel = dataSite.usingUser(userModel).createPrivateRandomSite();
restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).addFavoriteSite(privateSiteModel);
restClient.withCoreAPI().usingAuthUser()
.removeFavoriteSite(privateSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListDoesNotContain("id", privateSiteModel.getId());
}
}
e2e-test/java/org/alfresco/rest/favorites/DeleteFavoriteSiteFullTests.java
-185
View File
@@ -1,185 +0,0 @@
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.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 }, 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 }, 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 }, 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 }, executionType = ExecutionType.REGRESSION,
description = "Delete favorite site that is NOT favorite.")
public void adminUserRemovesDeletedFavoriteSiteThatIsNotFavorite() throws Exception
{
siteModel = dataSite.usingUser(userModel).createPublicRandomSite();
restClient.authenticateUser(dataUser.getAdminUser()).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}, 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}, 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}, 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/favorites/DeleteFavoriteSiteSanityTests.java
-174
View File
@@ -1,174 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.utility.constants.UserRole;
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 DeleteFavoriteSiteSanityTests extends RestTest
{
UserModel userModel;
SiteModel siteModel1;
SiteModel siteModel2;
UserModel searchedUser;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
siteModel1 = dataSite.usingUser(userModel).createPublicRandomSite();
siteModel2 = dataSite.usingUser(userModel).createPublicRandomSite();
}
@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)")
public void managerUserRemovesFavoriteSiteWithSuccess() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
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)")
public void collaboratorUserRemovesFavoriteSiteWithSuccess() throws Exception
{
UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(collaboratorUser, siteModel1, UserRole.SiteCollaborator);
dataSite.usingUser(collaboratorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(collaboratorUser).usingSite(siteModel2).addSiteToFavorites();
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)")
public void contributorUserRemovesFavoriteSiteWithSuccess() throws Exception
{
UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(contributorUser, siteModel1, UserRole.SiteContributor);
dataSite.usingUser(contributorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(contributorUser).usingSite(siteModel2).addSiteToFavorites();
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)")
public void consumerUserRemovesFavoriteSiteWithSuccess() throws Exception
{
UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(consumerUser, siteModel1, UserRole.SiteConsumer);
dataSite.usingUser(consumerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(consumerUser).usingSite(siteModel2).addSiteToFavorites();
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)")
public void adminUserRemovesAnyFavoriteSiteWithSuccess() throws Exception
{
UserModel adminUser = dataUser.getAdminUser();
UserModel anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(anyUser).usingSite(siteModel2).addSiteToFavorites();
restClient.authenticateUser(adminUser).withCoreAPI().usingUser(anyUser).removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE })
@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();
dataSite.usingUser(anotherUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(anotherUser).usingSite(siteModel2).addSiteToFavorites();
restClient.authenticateUser(userAuth).withCoreAPI().usingUser(anotherUser).removeFavoriteSite(siteModel1);
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)")
public void managerUserNotAuthorizedFailsToRemoveFavoriteSite() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
managerUser.setPassword("newpassword");
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1);
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/favorites/DeleteFavoriteSiteTests.java
+432
View File
@@ -0,0 +1,432 @@
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;
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 DeleteFavoriteSiteTests extends RestTest
{
private UserModel userModel, adminUserModel, adminTenantUser, tenantUser;
private SiteModel siteModel1, siteModel2;
private DataUser.ListUserWithRoles usersWithRoles;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
siteModel1 = dataSite.usingUser(userModel).createPublicRandomSite();
siteModel2 = dataSite.usingUser(userModel).createPublicRandomSite();
adminUserModel = dataUser.getAdminUser();
usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel1, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer,
UserRole.SiteContributor);
}
@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)")
public void managerUserRemovesFavoriteSiteWithSuccess() throws Exception
{
UserModel managerUser = usersWithRoles.getOneUserWithRole(UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
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 manager user is NOT Authorized to remove a site from its favorite sites list with Rest API when authentication fails (401)")
public void managerUserNotAuthorizedFailsToRemoveFavoriteSite() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
managerUser.setPassword("newpassword");
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED)
.assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE)
.containsErrorKey(RestErrorModel.API_DEFAULT_ERRORKEY);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
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 = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator);
dataSite.usingUser(collaboratorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(collaboratorUser).usingSite(siteModel2).addSiteToFavorites();
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.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
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 = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
dataSite.usingUser(contributorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(contributorUser).usingSite(siteModel2).addSiteToFavorites();
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.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
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 = usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer);
dataSite.usingUser(consumerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(consumerUser).usingSite(siteModel2).addSiteToFavorites();
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.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
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 anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(anyUser).usingSite(siteModel2).addSiteToFavorites();
restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(anyUser).removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE , TestGroup.REGRESSION})
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
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 userCannotRemoveAnotherUserFavoriteSite() throws Exception
{
UserModel userAuth = dataUser.usingAdmin().createRandomTestUser();
UserModel anotherUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anotherUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(anotherUser).usingSite(siteModel2).addSiteToFavorites();
restClient.authenticateUser(userAuth).withCoreAPI().usingUser(anotherUser).removeFavoriteSite(siteModel1);
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.REGRESSION })
@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.usingAdmin().createPublicRandomSite();
restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).addFavoriteSite(publicSiteModel);
restClient.withCoreAPI().usingAuthUser()
.removeFavoriteSite(publicSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListDoesNotContain("id", publicSiteModel.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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.usingAdmin().createModeratedRandomSite();
restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).addFavoriteSite(moderatedSiteModel);
restClient.withCoreAPI().usingAuthUser()
.removeFavoriteSite(moderatedSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListDoesNotContain("id", moderatedSiteModel.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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();
restClient.authenticateUser(userModel).withCoreAPI().usingUser(userModel).addFavoriteSite(privateSiteModel);
restClient.withCoreAPI().usingAuthUser()
.removeFavoriteSite(privateSiteModel);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingAuthUser().getFavoriteSites()
.assertThat().entriesListDoesNotContain("id", privateSiteModel.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser()
.removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
restClient.withCoreAPI().usingUser(managerUser).addFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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);
dataSite.usingUser(adminUserModel).usingSite(siteModel1).addSiteToFavorites();
restClient.withCoreAPI().usingMe().removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NO_CONTENT);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
// @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")
public void inexistentUserIsNotAbleToRemoveFavoriteSite() throws Exception
{
UserModel inexistentUser = new UserModel("inexistenUser", "password");
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(inexistentUser)
.removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "inexistenUser"));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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()))
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE)
.containsErrorKey(RestErrorModel.RELATIONSHIP_NOT_FOUND_ERRORKEY);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, 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(adminUserModel).usingSite(siteModel1).addSiteToFavorites();
restClient.authenticateUser(contributor)
.withCoreAPI().usingUser(adminUserModel).removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN)
.assertLastError()
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, 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(siteModel1).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1);
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError()
.containsSummary(String.format(RestErrorModel.NOT_FAVOURITE_SITE, siteModel1.getTitle()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Users removes from favorite a site that is already deleted.")
public void consumerUserRemovesDeletedFavoriteSite() throws Exception
{
SiteModel siteModel = dataSite.usingUser(userModel).createPublicRandomSite();
UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(consumerUser, siteModel, UserRole.SiteConsumer);
dataSite.usingUser(consumerUser).usingSite(siteModel).addSiteToFavorites();
dataSite.usingAdmin().deleteSite(siteModel);
restClient.authenticateUser(consumerUser).withCoreAPI().usingAuthUser().removeFavoriteSite(siteModel);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND,
consumerUser.getUsername(), siteModel.getId()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Delete favorite site that is NOT favorite.")
public void adminUserRemovesDeletedFavoriteSiteThatIsNotFavorite() throws Exception
{
SiteModel siteModel = dataSite.usingUser(userModel).createPublicRandomSite();
restClient.authenticateUser(adminUserModel).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.REGRESSION })
public void siteMemberIsNotAbleToDeleteFavoritesOfAnotherSiteMember() throws Exception
{
UserModel siteCollaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator);
dataSite.usingUser(siteCollaborator).usingSite(siteModel1).addSiteToFavorites();
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI()
.usingUser(siteCollaborator)
.removeFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN)
.assertLastError()
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Bug(id="MNT-16904")
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE}, 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.REGRESSION })
public void tenantIsNotAbleToDeleteFavoriteSiteWithInvalidNetworkID() throws Exception
{
adminTenantUser = UserModel.getAdminTenantUser();
restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser);
tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant");
SiteModel 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}, 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.REGRESSION })
public void tenantDeleteFavoriteSiteValidNetwork() throws Exception
{
adminTenantUser = UserModel.getAdminTenantUser();
restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser);
tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant");
SiteModel 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}, 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.REGRESSION })
public void tenantUserIsAbleToDeleteFavoriteSiteAddedByAdminSameNetwork() throws Exception
{
adminTenantUser = UserModel.getAdminTenantUser();
restClient.authenticateUser(adminUserModel).usingTenant().createTenant(adminTenantUser);
tenantUser = dataUser.usingUser(adminTenantUser).createUserWithTenant("uTenant");
SiteModel 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/favorites/DeleteFavoriteTests.java
+477
View File
@@ -0,0 +1,477 @@
package org.alfresco.rest.favorites;
import org.alfresco.dataprep.CMISUtil;
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.*;
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 DeleteFavoriteTests 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(CMISUtil.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.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 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());
}
// @Bug(id = "MNT-16904", description = "It fails only on environment with tenants")
@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 Exception
{
UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager);
siteManager.setPassword("wrongPassword");
restClient.authenticateUser(siteManager).withCoreAPI().usingAuthUser()
.deleteSiteFromFavorites(siteModel).assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Collaborator user deletes site from favorites with Rest API and status code is 204")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToDeleteFavorites() throws 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.REGRESSION,
description = "Verify Contributor user deletes site from favorites with Rest API and status code is 204")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToDeleteFavorites() throws 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.REGRESSION,
description = "Verify Consumer user delets site from favorites with Rest API and status code is 204")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToDeleteFavorites() throws 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());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Admin user deletes site from favorites with Rest API and status code is 204")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToDeleteFavorites() throws 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.REGRESSION,
description = "Verify admin deletes files from favorites with Rest API and status code is (204)")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToDeleteFavoriteFile() throws 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.REGRESSION })
public void adminIsAbleToDeleteFavoriteFolder() throws 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());
}
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
@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 admin user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsNotAbleToDeleteFavoritesOfAdminUser() throws 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="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.REGRESSION })
public void adminIsNotAbleToDeleteFavoritesOfASiteMember() throws 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="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.REGRESSION })
public void consumerIsNotAbleToDeleteFavoritesOfAnotherUser() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.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 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.REGRESSION })
public void collaboratorIsNotAbleToDeleteFavoriteOfAnotherUser() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.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.REGRESSION })
public void contributorIsNotAbleToDeleteFavoriteOfAnotherUser() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).withCoreAPI()
.usingAuthUser().addSiteToFavorites(siteModel);
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor)).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.REGRESSION })
public void adminIsNotAbleToDeleteFavoriteOfAnotherUser() throws 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 that status code is 404 if PersonID is incorrect - favorite file.")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION})
public void deleteFavoriteIfPersonIdNotExists() throws 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.REGRESSION})
public void deleteFavoriteIfPersonIdIsEmpty() throws 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.REGRESSION})
public void deleteFavoriteFileIfFavoriteIdIsIncorrect() throws 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.REGRESSION})
public void deleteFavoriteFileIfFavoriteIdNotExists() throws 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.REGRESSION})
public void deleteFavoriteSiteIfFavoriteIdNotExists() throws 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.REGRESSION})
public void deleteFavoriteFolderIfFavoriteIdNotExists() throws 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"));
}
@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.REGRESSION })
public void adminIsNotAbleToDeleteADeletedFavoriteFile() throws 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.REGRESSION })
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.REGRESSION })
public void adminDeletesFavoriteForNotFavouriteFile() throws Exception
{
fileModel = dataContent.usingSite(siteModel).createContent(CMISUtil.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 }, 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.REGRESSION })
public void tenantIsNotAbleToDeleteFavoriteSiteWithInvalidNetworkID() throws 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}, 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.REGRESSION })
public void tenantDeleteFavoriteSiteValidNetwork() throws 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}, 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.REGRESSION })
public void tenantUserIsAbleToDeleteFavoriteSiteAddedByAdminSameNetwork() throws 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/FavoritesIncludePathSanityTests.java → e2e-test/java/org/alfresco/rest/favorites/FavoritesIncludePathTests.java
+7 -12
View File
@@ -20,7 +20,7 @@ import org.testng.annotations.Test;
*
* @author meenal bhave
*/
public class FavoritesIncludePathSanityTests extends RestTest
public class FavoritesIncludePathTests extends RestTest
{
private UserModel adminUser;
private UserModel testUser1;
@@ -37,7 +37,6 @@ public class FavoritesIncludePathSanityTests extends RestTest
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
adminUser = dataUser.getAdminUser();
restClient.authenticateUser(adminUser);
@@ -54,7 +53,7 @@ public class FavoritesIncludePathSanityTests extends RestTest
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify that get favorite site request does not include Path")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES})
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION})
public void testGetFavoriteIncludePathForSite() throws Exception
{
restClient.authenticateUser(testUser1).withCoreAPI().usingAuthUser().includePath().getFavorite(siteModel1.getGuid());
@@ -64,7 +63,7 @@ public class FavoritesIncludePathSanityTests extends RestTest
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify that get favorite file or folder request includes path when requested")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES})
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION})
public void testGetFavouriteIncludePathForFileFolder() throws Exception
{
STEP("1. Favourite Folder and File");
@@ -97,7 +96,7 @@ public class FavoritesIncludePathSanityTests extends RestTest
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify path in get favorites")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES})
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION})
public void testGetFavouritesIncludePath() throws Exception
{
STEP("1. Favourite Folder and File");
@@ -117,10 +116,9 @@ public class FavoritesIncludePathSanityTests extends RestTest
restClient.onResponse().assertThat().body("list.entries.entry.target.site.id", org.hamcrest.Matchers.contains(siteModel1.getId()));
restClient.onResponse().assertThat().body("list.entries.entry.target.site.path", org.hamcrest.Matchers.contains(org.hamcrest.Matchers.nullValue()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify path in post favorites")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES})
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION})
public void testPostFavouritesIncludePath() throws Exception
{
STEP("1. Favourite Site");
@@ -140,9 +138,6 @@ public class FavoritesIncludePathSanityTests extends RestTest
restClient.authenticateUser(testUser1).withCoreAPI().usingAuthUser().includePath().addFileToFavorites(fileInSubFolder);
restClient.assertStatusCodeIs(HttpStatus.CREATED);
restClient.onResponse().assertThat().body("entry.target.file.id", org.hamcrest.Matchers.equalTo(fileInSubFolder.getNodeRefWithoutVersion()));
restClient.onResponse().assertThat().body("entry.target.file.path", org.hamcrest.Matchers.notNullValue());
}
restClient.onResponse().assertThat().body("entry.target.file.path", org.hamcrest.Matchers.notNullValue());
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteCoreTests.java
-130
View File
@@ -1,130 +0,0 @@
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.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;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
public class GetFavoriteCoreTests extends RestTest {
private UserModel adminUserModel;
private SiteModel siteModel;
private FolderModel folderModel;
private FileModel fileModel;
private ListUserWithRoles usersWithRoles;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception {
adminUserModel = dataUser.getAdminUser();
restClient.authenticateUser(adminUserModel);
siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
folderModel = dataContent.usingUser(adminUserModel).usingSite(siteModel).createFolder();
fileModel = dataContent.usingUser(adminUserModel).usingResource(folderModel)
.createContent(DocumentType.TEXT_PLAIN);
usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator,
UserRole.SiteConsumer, UserRole.SiteContributor);
}
@TestRail(section = { TestGroup.REST_API,
TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify get favorite site when person id does't exist")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void getFavoriteSiteWhenPersonIdNotExist() throws JsonToModelConversionException, Exception {
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);
}
@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")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void getFavoriteSiteWhenFavoriteIdNotExist() throws JsonToModelConversionException, Exception {
restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel);
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).getFavorite("invalidId");
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "invalidId"))
.statusCodeIs(HttpStatus.NOT_FOUND)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE)
.containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY);
}
@TestRail(section = { TestGroup.REST_API,
TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify get favorite user doesn't have any favorite site, file or folder")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void getFavoriteSiteForUserWithoutAnyFavorites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteManager).getUsername(), siteModel.getGuid()))
.statusCodeIs(HttpStatus.NOT_FOUND)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE)
.containsErrorKey(RestErrorModel.RELATIONSHIP_NOT_FOUND_ERRORKEY);
}
@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 getFavoriteSiteUsingMe() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favoriteSite = restClient.withCoreAPI().usingMe().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteSite.assertThat().field("targetGuid").is(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").is(fileModel.getNodeRefWithoutVersion());
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteFullTests.java
-207
View File
@@ -1,207 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.dataprep.CMISUtil.DocumentType;
import org.alfresco.dataprep.SiteService.Visibility;
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.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 GetFavoriteFullTests extends RestTest
{
private UserModel adminUserModel;
private SiteModel siteModel;
private FolderModel folderModel;
private FileModel fileModel;
private ListUserWithRoles usersWithRoles;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception {
adminUserModel = dataUser.getAdminUser();
restClient.authenticateUser(adminUserModel);
siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
folderModel = dataContent.usingUser(adminUserModel).usingSite(siteModel).createFolder();
fileModel = dataContent.usingUser(adminUserModel).usingResource(folderModel)
.createContent(DocumentType.TEXT_PLAIN);
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 the get favorite request for invalid network id")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL, TestGroup.NETWORKS })
public void getFavoriteSiteWithInvalidNetworkId() throws Exception
{
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").is(siteModel.getGuid());
favoriteSite.getTarget().getSite()
.assertThat().field("guid").is(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").is(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).addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.authenticateUser(collaborator).withParams("properties=tas")
.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().fieldsCount().is(0);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify all values from get favorite rest api for a file")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void verifyRequestFieldsforGetFavoriteFile() throws JsonToModelConversionException, Exception
{
UserModel contributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
restClient.authenticateUser(contributor);
restClient.withCoreAPI().usingUser(contributor).addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.authenticateUser(contributor)
.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion())
.and().field("target.file.isFile").is("true")
.and().field("target.file.mimeType").is("text/plain")
.and().field("target.file.isFolder").is("false")
.and().field("target.file.createdBy").is(adminUserModel.getUsername())
.and().field("target.file.versionLabel").is("1.0")
.and().field("target.file.name").is(fileModel.getName())
.and().field("target.file.parentId").is(folderModel.getNodeRef())
.and().field("target.file.guid").is(fileModel.getNodeRefWithoutVersion())
.and().field("target.file.modifiedBy").is(adminUserModel.getUsername())
.and().field("target.file.id").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify all values from get favorite rest api for a site")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void verifyRequestFieldsforGetFavoriteSite() throws JsonToModelConversionException, Exception
{
UserModel contributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
restClient.authenticateUser(contributor);
restClient.withCoreAPI().usingUser(contributor).addFavoriteSite(siteModel);
RestPersonFavoritesModel favoriteSite = restClient.authenticateUser(contributor)
.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteSite.assertThat().field("targetGuid").is(siteModel.getGuid())
.and().field("target.site.role").is(UserRole.SiteContributor.toString())
.and().field("target.site.visibility").is(Visibility.PUBLIC.toString())
.and().field("target.site.guid").is(siteModel.getGuid())
.and().field("target.site.description").is(siteModel.getDescription())
.and().field("target.site.id").is(siteModel.getId())
.and().field("target.site.preset").is("site-dashboard")
.and().field("target.site.title").is(siteModel.getTitle());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify all values from get favorite rest api for a folder")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.FULL })
public void verifyRequestFieldsforGetFavoriteFolder() throws JsonToModelConversionException, Exception
{
UserModel contributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
restClient.authenticateUser(contributor);
restClient.withCoreAPI().usingUser(contributor).addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.authenticateUser(contributor)
.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef())
.and().field("target.folder.isFile").is("false")
.and().field("target.folder.isFolder").is("true")
.and().field("target.folder.createdBy").is(adminUserModel.getUsername())
.and().field("target.folder.name").is(folderModel.getName())
.and().field("target.folder.guid").is(folderModel.getNodeRef())
.and().field("target.folder.modifiedBy").is(adminUserModel.getUsername())
.and().field("target.folder.id").is(folderModel.getNodeRef());
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSanityTests.java
-293
View File
@@ -1,293 +0,0 @@
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.rest.model.RestPersonFavoritesModel;
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 GetFavoriteSanityTests extends RestTest
{
private UserModel adminUserModel;
private SiteModel siteModel;
private FolderModel folderModel;
private FileModel fileModel;
private ListUserWithRoles usersWithRoles;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
adminUserModel = dataUser.getAdminUser();
restClient.authenticateUser(adminUserModel);
siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
folderModel = dataContent.usingUser(adminUserModel).usingSite(siteModel).createFolder();
fileModel = dataContent.usingUser(adminUserModel).usingResource(folderModel).createContent(DocumentType.TEXT_PLAIN);
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 gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void adminIsAbleToRetrieveFavoritesSite() throws JsonToModelConversionException, Exception
{
restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel);
RestPersonFavoritesModel favoriteSite = restClient.withCoreAPI().usingUser(adminUserModel).getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteSite.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Admin user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void adminIsAbleToRetrieveFavoritesFolder() throws JsonToModelConversionException, Exception
{
restClient.withCoreAPI().usingUser(adminUserModel).addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingUser(adminUserModel).getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Admin user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void adminIsAbleToRetrieveFavoritesFile() throws JsonToModelConversionException, Exception
{
restClient.withCoreAPI().usingUser(adminUserModel).addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingUser(adminUserModel).getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavoriteSite() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavoriteFolder() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavoriteFile() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Collaborator user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void collaboratorIsAbleToRetrieveFavoriteSite() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify collaborator user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void collaboratorIsAbleToRetrieveFavoriteFolder() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify collaborator user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void collaboratorIsAbleToRetrieveFavoriteFile() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Contributor user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void contributorIsAbleToRetrieveFavoriteSite() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid()); ;
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify contributor user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void contributorIsAbleToRetrieveFavoriteFolder() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify contributor user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void contributorIsAbleToRetrieveFavoriteFile() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Consumer user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void consumerIsAbleToRetrieveFavorites() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify consumer user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void consumerIsAbleToRetrieveFavoriteFolder() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify consumer user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void consumerIsAbleToRetrieveFavoriteFile() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify user doesn't get favorite site of another user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES })
public void userIsNotAbleToRetrieveFavoriteSiteOfAnotherUser() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify user doesn't get favorite site of admin user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES })
public void userIsNotAbleToRetrieveFavoritesOfAdminUser() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingUser(adminUserModel).getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, adminUserModel.getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify admin user doesn't get favorite site of another user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES })
public void adminIsNotAbleToRetrieveFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI()
.usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@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", description = "fails only on environment with tenants")
public void userIsNotAbleToRetrieveFavoriteSiteIfAuthenticationFails() 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)
.assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSiteCoreTests.java
-62
View File
@@ -1,62 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.utility.data.DataUser;
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;
/**
* Created by Claudia Agache on 11/22/2016.
*/
public class GetFavoriteSiteCoreTests extends RestTest
{
UserModel userModel;
SiteModel site1;
@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.CORE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify invalid request returns status 404 when personId does not exist")
public void getFavoriteSiteWithNonExistentPersonId() throws Exception
{
UserModel someUser = new UserModel("someUser", DataUser.PASSWORD);
restClient.authenticateUser(userModel).withCoreAPI().usingUser(someUser).getFavoriteSite(site1);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "someUser"));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify invalid request returns status 404 when siteId does not exist")
public void getFavoriteSiteWithNonExistentSiteId() throws Exception
{
SiteModel nonExistentSite = new SiteModel("nonExistentSite");
restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser().getFavoriteSite(nonExistentSite);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, userModel.getUsername(), nonExistentSite.getId()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify User fails to get specific favorite site of admin with Rest API and response is 403")
public void userFailsToGetFavoriteSiteOfAdmin() throws Exception
{
restClient.authenticateUser(userModel).withCoreAPI().usingUser(dataUser.getAdminUser()).getFavoriteSite(site1);
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSiteFullTests.java
-177
View File
@@ -1,177 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.dataprep.CMISUtil.DocumentType;
import org.alfresco.dataprep.SiteService.Visibility;
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.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.apache.commons.lang3.RandomStringUtils;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
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 invalid request returns status 404 when providing file name instead of site id")
public void getFavoriteSiteUsingFile() throws Exception
{
FileModel file = dataContent.usingSite(site1).createContent(DocumentType.TEXT_PLAIN);
SiteModel siteFolder = new SiteModel(file.getName());
restSiteModel = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getFavoriteSite(siteFolder);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, userModel.getUsername(), file.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 401 when using invalid network")
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/favorites/GetFavoriteSiteSanityTests.java
-137
View File
@@ -1,137 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.rest.model.RestSiteModel;
import org.alfresco.utility.constants.UserRole;
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;
/**
* Tests for Get Favorite Sites (/people/{personId}/preferences) RestAPI call
*
* @author Cristina Axinte
*/
public class GetFavoriteSiteSanityTests extends RestTest
{
UserModel userModel;
SiteModel siteModel1;
SiteModel siteModel2;
UserModel searchedUser;
private RestSiteModel restSiteModel;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
siteModel1 = dataSite.usingUser(userModel).createPublicRandomSite();
siteModel2 = dataSite.usingUser(userModel).createPublicRandomSite();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user gets its specific favorite site with Rest API and response is successful (200)")
public void managerUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify collaborator user gets its specific favorite site with Rest API and response is successful (200)")
public void collaboratorUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(collaboratorUser, siteModel1, UserRole.SiteCollaborator);
dataSite.usingUser(collaboratorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(collaboratorUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(collaboratorUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify contributor user gets its specific favorite site with Rest API and response is successful (200)")
public void contributorUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(contributorUser, siteModel1, UserRole.SiteContributor);
dataSite.usingUser(contributorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(contributorUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(contributorUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify consumer user gets its specific favorite site with Rest API and response is successful (200)")
public void consumerUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(consumerUser, siteModel1, UserRole.SiteConsumer);
dataSite.usingUser(consumerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(consumerUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(consumerUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify admin user gets specific favorite site of any user with Rest API and response is successful (200)")
public void adminUserGetsAnyFavoriteSiteWithSuccess() throws Exception
{
UserModel adminUset = dataUser.getAdminUser();
UserModel anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(anyUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(adminUset).withCoreAPI().usingUser(anyUser).getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user fails to get specific favorite site of another user with Rest API and response is successful (403)")
public void managerUserFailsToGetFavoriteSiteOfAnotherUser() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingUser(userModel).getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@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 gets its specific favorite site with Rest API when authentication fails (401)")
@Bug(id="MNT-16904", description = "It fails only on environment with tenants")
public void managerUserNotAuthorizedFailsToGetFavoriteSite() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
managerUser.setPassword("newpassword");
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSiteTests.java
+302
View File
@@ -0,0 +1,302 @@
package org.alfresco.rest.favorites;
import org.alfresco.dataprep.CMISUtil;
import org.alfresco.dataprep.SiteService;
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.data.DataUser;
import org.alfresco.utility.model.*;
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.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* Tests for Get Favorite Sites (/people/{personId}/preferences) RestAPI call
*
* @author Cristina Axinte
*/
public class GetFavoriteSiteTests extends RestTest
{
private UserModel userModel;
private SiteModel siteModel1;
private SiteModel siteModel2;
private RestSiteModel restSiteModel;
private DataUser.ListUserWithRoles usersWithRoles;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
siteModel1 = dataSite.usingUser(userModel).createPublicRandomSite();
siteModel2 = dataSite.usingUser(userModel).createPublicRandomSite();
usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel1, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer,
UserRole.SiteContributor);
dataSite.usingUser(userModel).usingSite(siteModel1).addSiteToFavorites();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user gets its specific favorite site with Rest API and response is successful (200)")
public void managerUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel managerUser = usersWithRoles.getOneUserWithRole(UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify collaborator user gets its specific favorite site with Rest API and response is successful (200)")
public void collaboratorUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel collaboratorUser = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator);
dataSite.usingUser(collaboratorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(collaboratorUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(collaboratorUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify contributor user gets its specific favorite site with Rest API and response is successful (200)")
public void contributorUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel contributorUser = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
dataSite.usingUser(contributorUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(contributorUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(contributorUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify consumer user gets its specific favorite site with Rest API and response is successful (200)")
public void consumerUserGetsFavoriteSiteWithSuccess() throws Exception
{
UserModel consumerUser = usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer);
dataSite.usingUser(consumerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(consumerUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(consumerUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify admin user gets specific favorite site of any user with Rest API and response is successful (200)")
public void adminUserGetsAnyFavoriteSiteWithSuccess() throws Exception
{
UserModel adminUser = dataUser.getAdminUser();
UserModel anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(anyUser).usingSite(siteModel2).addSiteToFavorites();
restSiteModel = restClient.authenticateUser(adminUser).withCoreAPI().usingUser(anyUser).getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId()).and().field("title").isNotNull();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify manager user fails to get specific favorite site of another user with Rest API and response is successful (403)")
public void managerUserFailsToGetFavoriteSiteOfAnotherUser() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingUser(userModel).getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@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 gets its specific favorite site with Rest API when authentication fails (401)")
// @Bug(id="MNT-16904", description = "It fails only on environment with tenants")
public void managerUserNotAuthorizedFailsToGetFavoriteSite() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel1, UserRole.SiteManager);
dataSite.usingUser(managerUser).usingSite(siteModel1).addSiteToFavorites();
dataSite.usingUser(managerUser).usingSite(siteModel2).addSiteToFavorites();
managerUser.setPassword("newpassword");
restClient.authenticateUser(managerUser).withCoreAPI().usingAuthUser().getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify invalid request returns status 404 when personId does not exist")
public void getFavoriteSiteWithNonExistentPersonId() throws Exception
{
UserModel someUser = new UserModel("someUser", DataUser.PASSWORD);
restClient.authenticateUser(userModel).withCoreAPI().usingUser(someUser).getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "someUser"));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify invalid request returns status 404 when siteId does not exist")
public void getFavoriteSiteWithNonExistentSiteId() throws Exception
{
SiteModel nonExistentSite = new SiteModel("nonExistentSite");
restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser().getFavoriteSite(nonExistentSite);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, userModel.getUsername(), nonExistentSite.getId()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify User fails to get specific favorite site of admin with Rest API and response is 403")
public void userFailsToGetFavoriteSiteOfAdmin() throws Exception
{
restClient.authenticateUser(userModel).withCoreAPI().usingUser(dataUser.getAdminUser()).getFavoriteSite(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, userSpecialChars.getUsername()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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.REGRESSION })
@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(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, user.getUsername(), siteModel1.getId()))
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE)
.containsErrorKey(RestErrorModel.RELATIONSHIP_NOT_FOUND_ERRORKEY);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId())
.and().field("title").is(siteModel1.getTitle())
.and().field("role").is(UserRole.SiteManager.toString())
.and().field("visibility").is(SiteService.Visibility.PUBLIC.toString())
.and().field("guid").isNotEmpty()
.and().field("description").is(siteModel1.getDescription())
.and().field("preset").is("site-dashboard");
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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(siteModel1).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.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify invalid request returns status 404 when providing file name instead of site id")
public void getFavoriteSiteUsingFile() throws Exception
{
FileModel file = dataContent.usingSite(siteModel1).createContent(CMISUtil.DocumentType.TEXT_PLAIN);
SiteModel siteFolder = new SiteModel(file.getName());
restSiteModel = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getFavoriteSite(siteFolder);
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, userModel.getUsername(), file.getName()));
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().field("id").is(siteModel1.getId())
.and().field("title").is(siteModel1.getTitle());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@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(siteModel1);
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST)
.assertLastError().containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify request returns status 401 when using invalid network")
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/favorites/GetFavoriteSitesCoreTests.java
-131
View File
@@ -1,131 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.rest.model.RestSiteModelsCollection;
import org.alfresco.utility.data.DataUser;
import org.alfresco.utility.data.RandomData;
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;
public class GetFavoriteSitesCoreTests extends RestTest
{
UserModel userModel;
UserModel testUser1;
SiteModel siteModel;
private RestSiteModelsCollection restSiteModelsCollection;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
testUser1 = dataUser.createRandomTestUser();
siteModel = dataSite.usingUser(userModel).createPublicRandomSite();
dataSite.usingUser(userModel).usingSite(siteModel).addSiteToFavorites();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request status code is 404 for a personId that does not exist")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
public void getFavoriteSitesReturns404ForAPersonIdThatDoesNotExist() throws Exception
{
UserModel invalidUser = new UserModel(RandomData.getRandomName("User"), DataUser.PASSWORD);
restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(invalidUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY)
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, invalidUser.getUsername()))
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request status code is 403 if the user doesn't have access to the person favorite sites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
public void userCannotGetFavoriteSitesForAnotherUser() throws Exception
{
restClient.authenticateUser(userModel).withCoreAPI().usingUser(testUser1).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError()
.containsErrorKey(RestErrorModel.PERMISSION_DENIED_ERRORKEY)
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that admin has access to regular user site favorites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
public void adminCanGetFavoriteSitesForARegularUser() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(userModel).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.assertThat().entriesListContains("id", siteModel.getId());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that regular user can not see admin user site favorites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
public void regularUserCannotGetFavoriteSitesForAdminUser() throws Exception
{
restClient.authenticateUser(testUser1).withCoreAPI().usingUser(dataUser.getAdminUser()).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError()
.containsErrorKey(RestErrorModel.PERMISSION_DENIED_ERRORKEY)
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that favorite site can be removed")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
public void verifyThatFavoriteSiteCanBeRemoved() throws Exception
{
UserModel randomTestUser = dataUser.createRandomTestUser();
dataSite.usingUser(randomTestUser).usingSite(siteModel).addSiteToFavorites();
restSiteModelsCollection = restClient.authenticateUser(randomTestUser).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.assertThat().entriesListContains("id", siteModel.getId());
dataSite.usingUser(randomTestUser).usingSite(siteModel).removeSiteFromFavorites();
restSiteModelsCollection = restClient.withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsEmpty();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that if maxItems param is invalid status code returned is BAD_REQUEST (400)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
public void getFavoriteSitesMaxItemsInvalidValueTest() throws Exception
{
restClient.authenticateUser(userModel).withParams("maxItems=-1").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS);
restClient.authenticateUser(userModel).withParams("maxItems=abc").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(String.format(RestErrorModel.INVALID_MAXITEMS, "abc"));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that if skipCount param is invalid status code returned is BAD_REQUEST (400)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.CORE })
public void getFavoriteSitesSkipCountInvalidValueTest() throws Exception
{
restClient.authenticateUser(userModel).withParams("skipCount=-1").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(RestErrorModel.NEGATIVE_VALUES_SKIPCOUNT);
restClient.authenticateUser(userModel).withParams("skipCount=abc").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(String.format(RestErrorModel.INVALID_SKIPCOUNT, "abc"));
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSitesFullTests.java
-159
View File
@@ -1,159 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.rest.model.RestSiteModel;
import org.alfresco.rest.model.RestSiteModelsCollection;
import org.alfresco.utility.data.RandomData;
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;
public class GetFavoriteSitesFullTests extends RestTest
{
UserModel userModel;
SiteModel siteModel;
SiteModel testSite1;
SiteModel testSite2;
private RestSiteModelsCollection restSiteModelsCollection;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
siteModel = new SiteModel("A-" + RandomData.getRandomAlphanumeric());
testSite1 = new SiteModel("B-" + RandomData.getRandomAlphanumeric());
testSite2 = new SiteModel("C-" + RandomData.getRandomAlphanumeric());
dataSite.usingUser(userModel).createSite(siteModel);
dataSite.usingUser(userModel).createSite(testSite1);
dataSite.usingUser(userModel).createSite(testSite2);
dataSite.usingUser(userModel).usingSite(testSite2).addSiteToFavorites();
dataSite.usingUser(userModel).usingSite(testSite1).addSiteToFavorites();
dataSite.usingUser(userModel).usingSite(siteModel).addSiteToFavorites();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status using -me- string in place of personId is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void userGetsFavoriteSiteWithSuccessUsingMEForRequest() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingMe().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.and().entriesListContains("id", siteModel.getId())
.and().paginationExist();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status for a user that has no favorite sites is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void getFavoriteSiteRequestForUserWithNoFavoriteSitesIsSuccessful() throws Exception
{
UserModel randomTestUser = dataUser.createRandomTestUser();
restSiteModelsCollection = restClient.authenticateUser(randomTestUser).withCoreAPI().usingMe().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsEmpty();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status for a user with several favorite sites is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void getFavoriteSiteRequestForUserWithSeveralFavoriteSitesIsSuccessful() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(userModel).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.and().entriesListContains("id", siteModel.getId())
.and().entriesListContains("id", testSite1.getId())
.and().entriesListContains("id", testSite2.getId())
.and().paginationExist();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request can only be called with a positive maxItems param")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void userCanNotGetFavoriteSitesWith0MaxItems() throws Exception
{
restClient.authenticateUser(userModel).withParams("maxItems=0").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST)
.assertLastError()
.containsErrorKey(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS)
.containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status code for a high skipCount param is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void userCanGetFavoriteSitesWithHighSkipCount() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(userModel).withParams("skipCount=999999999").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsEmpty()
.assertThat().paginationField("skipCount").is("999999999");
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify admin gets favorite sites for username with special chars with Rest API and response status is NOT_FOUND (404)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void getFavoriteSitesRequestForPersonIDWithSpecialCharacters() throws Exception
{
String randomData = RandomData.getRandomAlphanumeric();
UserModel userSpecialChars = dataUser.usingAdmin().createUser(randomData + "~!@#$%^&[]{}|\\;':\",./<>", "password");
//setting the encoded text for username
userSpecialChars.setUsername(randomData + "~!%40%23%24%25%5E%26%5B%5D%7B%7D%7C%5C%3B%27%3A%22%2C.%2F%3C%3E");
restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(userSpecialChars).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY)
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, randomData + "~!%40%23%24%25%5E%26%5B%5D%7B%7D%7C%5C%3B%27%3A%22%2C.%2F%3C%3E"))
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that user can retrieve the last 2 favorite sites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void userCanRetrieveLast2FavoriteSites() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(userModel).withParams("skipCount=1&maxCount=2").
withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.assertThat().entriesListCountIs(2)
.assertThat().entriesListContains("id", testSite1.getId())
.assertThat().entriesListContains("id", testSite2.getId());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request applies valid properties param")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void getFavoriteSitesRequestWithValidPropertiesParam() throws Exception
{
RestSiteModel restSiteModel = restClient.authenticateUser(userModel).withParams("properties=title")
.withCoreAPI().usingAuthUser().getFavoriteSites().getOneRandomEntry().onModel();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().fieldsCount().is(1)
.assertThat().field("title").isNotEmpty();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request applies invalid properties param")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.FULL })
public void getFavoriteSitesRequestWithInvalidPropertiesParam() throws Exception
{
restClient.authenticateUser(userModel).withParams("properties=tas").withCoreAPI().usingAuthUser()
.getFavoriteSites().getOneRandomEntry().onModel().assertThat().fieldsCount().is(0);
restClient.assertStatusCodeIs(HttpStatus.OK);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSitesSanityTests.java
-123
View File
@@ -1,123 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.rest.model.RestSiteModelsCollection;
import org.alfresco.utility.constants.UserRole;
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 GetFavoriteSitesSanityTests extends RestTest
{
UserModel userModel;
SiteModel siteModel;
private RestSiteModelsCollection restSiteModelsCollection;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
siteModel = dataSite.usingUser(userModel).createPublicRandomSite();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify manager user fails to get an user favorite sites with Rest API (403)")
public void managerUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel, UserRole.SiteManager);
UserModel anotherUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anotherUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingUser(anotherUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify collaborator user fails to get an user favorite sites with Rest API (403)")
public void collaboratorUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(collaboratorUser, siteModel, UserRole.SiteCollaborator);
UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(contributorUser, siteModel, UserRole.SiteContributor);
dataSite.usingUser(contributorUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(collaboratorUser).withCoreAPI().usingUser(contributorUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify contributor user fails to get an user favorite sites with Rest API (403)")
public void contributorUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser();
UserModel contributorUser2 = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(contributorUser, siteModel, UserRole.SiteContributor);
dataUser.usingUser(userModel).addUserToSite(contributorUser2, siteModel, UserRole.SiteContributor);
dataSite.usingUser(contributorUser2).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(contributorUser).withCoreAPI().usingUser(contributorUser2).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify consumer user fails to get an user favorite sites with Rest API (403)")
public void consumerUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser();
UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(consumerUser, siteModel, UserRole.SiteConsumer);
dataUser.usingUser(collaboratorUser).addUserToSite(collaboratorUser, siteModel, UserRole.SiteCollaborator);
dataSite.usingUser(collaboratorUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(consumerUser).withCoreAPI().usingUser(collaboratorUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify admin user gets its favorite sites with Rest API and response is successful (200)")
public void adminUserGetsFavoriteSitesWithSuccess() throws Exception
{
UserModel adminUser = dataUser.getAdminUser();
UserModel anotherUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anotherUser).usingSite(siteModel).addSiteToFavorites();
restSiteModelsCollection = restClient.authenticateUser(adminUser).withCoreAPI().usingUser(anotherUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty().and().paginationExist().and().entriesListContains("id", siteModel.getId());
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify any user gets its own user favorite sites with Rest API and response is successful (200)")
public void anyUserGetsItsUserFavoriteSites() throws Exception
{
UserModel anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel).addSiteToFavorites();
restSiteModelsCollection = restClient.authenticateUser(anyUser).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty().and().entriesListContains("id", siteModel.getId()).and().paginationExist();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify any user is NOT Authorized to get its favorite sites with Rest API when authentication fails (401)")
@Bug(id = "MNT-16904", description = "It fails only on environment with tenants")
public void anyUserNotAuthenticatedIsNotAuthorizedToGetFavoriteSites() throws Exception
{
UserModel anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel).addSiteToFavorites();
anyUser.setPassword("newpassword");
restClient.authenticateUser(anyUser).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteSitesTests.java
+344
View File
@@ -0,0 +1,344 @@
package org.alfresco.rest.favorites;
import org.alfresco.rest.RestTest;
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.data.DataUser;
import org.alfresco.utility.data.RandomData;
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 GetFavoriteSitesTests extends RestTest
{
private UserModel userModel, testUser1;
private SiteModel siteModel, testSite1, testSite2, testSite3;
private RestSiteModelsCollection restSiteModelsCollection;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
userModel = dataUser.createRandomTestUser();
testUser1 = dataUser.createRandomTestUser();
siteModel = dataSite.usingUser(userModel).createPublicRandomSite();
testSite1 = new SiteModel("A-" + RandomData.getRandomAlphanumeric());
testSite2 = new SiteModel("B-" + RandomData.getRandomAlphanumeric());
testSite3 = new SiteModel("C-" + RandomData.getRandomAlphanumeric());
dataSite.usingUser(userModel).usingSite(siteModel).addSiteToFavorites();
dataSite.usingUser(testUser1).createSite(testSite1);
dataSite.usingUser(testUser1).createSite(testSite2);
dataSite.usingUser(testUser1).createSite(testSite3);
dataSite.usingUser(testUser1).usingSite(testSite3).addSiteToFavorites();
dataSite.usingUser(testUser1).usingSite(testSite2).addSiteToFavorites();
dataSite.usingUser(testUser1).usingSite(testSite1).addSiteToFavorites();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify manager user fails to get an user favorite sites with Rest API (403)")
public void managerUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel managerUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(managerUser, siteModel, UserRole.SiteManager);
UserModel anotherUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anotherUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(managerUser).withCoreAPI().usingUser(anotherUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify collaborator user fails to get an user favorite sites with Rest API (403)")
public void collaboratorUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(collaboratorUser, siteModel, UserRole.SiteCollaborator);
UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(contributorUser, siteModel, UserRole.SiteContributor);
dataSite.usingUser(contributorUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(collaboratorUser).withCoreAPI().usingUser(contributorUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify contributor user fails to get an user favorite sites with Rest API (403)")
public void contributorUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel contributorUser = dataUser.usingAdmin().createRandomTestUser();
UserModel contributorUser2 = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(contributorUser, siteModel, UserRole.SiteContributor);
dataUser.usingUser(userModel).addUserToSite(contributorUser2, siteModel, UserRole.SiteContributor);
dataSite.usingUser(contributorUser2).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(contributorUser).withCoreAPI().usingUser(contributorUser2).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION, description = "Verify consumer user fails to get an user favorite sites with Rest API (403)")
public void consumerUserFailsToGetAnUserFavoriteSites() throws Exception
{
UserModel consumerUser = dataUser.usingAdmin().createRandomTestUser();
UserModel collaboratorUser = dataUser.usingAdmin().createRandomTestUser();
dataUser.usingUser(userModel).addUserToSite(consumerUser, siteModel, UserRole.SiteConsumer);
dataUser.usingUser(collaboratorUser).addUserToSite(collaboratorUser, siteModel, UserRole.SiteCollaborator);
dataSite.usingUser(collaboratorUser).usingSite(siteModel).addSiteToFavorites();
restClient.authenticateUser(consumerUser).withCoreAPI().usingUser(collaboratorUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError().containsSummary(RestErrorModel.PERMISSION_WAS_DENIED);
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify any user gets its own user favorite sites with Rest API and response is successful (200)")
public void anyUserGetsHisFavoriteSites() throws Exception
{
UserModel anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel).addSiteToFavorites();
restSiteModelsCollection = restClient.authenticateUser(anyUser).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty().and().entriesListContains("id", siteModel.getId()).and().paginationExist();
}
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.SANITY })
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.SANITY, description = "Verify any user is NOT Authorized to get its favorite sites with Rest API when authentication fails (401)")
// @Bug(id = "MNT-16904", description = "It fails only on environment with tenants")
public void unauthenticatedUserIsNotAuthorizedToGetFavoriteSites() throws Exception
{
UserModel anyUser = dataUser.usingAdmin().createRandomTestUser();
dataSite.usingUser(anyUser).usingSite(siteModel).addSiteToFavorites();
anyUser.setPassword("newpassword");
restClient.authenticateUser(anyUser).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED).assertLastError()
.containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request status code is 404 for a personId that does not exist")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSitesReturns404ForAPersonIdThatDoesNotExist() throws Exception
{
UserModel invalidUser = new UserModel(RandomData.getRandomName("User"), DataUser.PASSWORD);
restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(invalidUser).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY)
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, invalidUser.getUsername()))
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request status code is 403 if the user doesn't have access to the person favorite sites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void userCannotGetFavoriteSitesForAnotherUser() throws Exception
{
restClient.authenticateUser(userModel).withCoreAPI().usingUser(testUser1).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError()
.containsErrorKey(RestErrorModel.PERMISSION_DENIED_ERRORKEY)
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that admin has access to regular user site favorites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void adminCanGetFavoriteSitesForARegularUser() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(userModel).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.assertThat().entriesListContains("id", siteModel.getId());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that regular user can not see admin user site favorites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void regularUserCannotGetFavoriteSitesForAdminUser() throws Exception
{
restClient.authenticateUser(testUser1).withCoreAPI().usingUser(dataUser.getAdminUser()).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.FORBIDDEN).assertLastError()
.containsErrorKey(RestErrorModel.PERMISSION_DENIED_ERRORKEY)
.containsSummary(RestErrorModel.PERMISSION_WAS_DENIED)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that favorite site can be removed")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void verifyThatFavoriteSiteCanBeRemoved() throws Exception
{
UserModel randomTestUser = dataUser.createRandomTestUser();
dataSite.usingUser(randomTestUser).usingSite(siteModel).addSiteToFavorites();
restSiteModelsCollection = restClient.authenticateUser(randomTestUser).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.assertThat().entriesListContains("id", siteModel.getId());
dataSite.usingUser(randomTestUser).usingSite(siteModel).removeSiteFromFavorites();
restSiteModelsCollection = restClient.withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsEmpty();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that if maxItems param is invalid status code returned is BAD_REQUEST (400)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSitesMaxItemsInvalidValueTest() throws Exception
{
restClient.authenticateUser(userModel).withParams("maxItems=-1").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS);
restClient.authenticateUser(userModel).withParams("maxItems=abc").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(String.format(RestErrorModel.INVALID_MAXITEMS, "abc"));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that if skipCount param is invalid status code returned is BAD_REQUEST (400)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSitesSkipCountInvalidValueTest() throws Exception
{
restClient.authenticateUser(userModel).withParams("skipCount=-1").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(RestErrorModel.NEGATIVE_VALUES_SKIPCOUNT);
restClient.authenticateUser(userModel).withParams("skipCount=abc").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError()
.containsSummary(String.format(RestErrorModel.INVALID_SKIPCOUNT, "abc"));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status using -me- string in place of personId is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void userGetsFavoriteSiteWithSuccessUsingMEForRequest() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(testUser1).withCoreAPI().usingMe().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.and().entriesListContains("id", testSite1.getId())
.and().paginationExist();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status for a user that has no favorite sites is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSiteRequestForUserWithNoFavoriteSitesIsSuccessful() throws Exception
{
UserModel randomTestUser = dataUser.createRandomTestUser();
restSiteModelsCollection = restClient.authenticateUser(randomTestUser).withCoreAPI().usingMe().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsEmpty();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status for a user with several favorite sites is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSiteRequestForUserWithSeveralFavoriteSitesIsSuccessful() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(testUser1).withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.and().entriesListContains("id", testSite1.getId())
.and().entriesListContains("id", testSite2.getId())
.and().entriesListContains("id", testSite3.getId())
.and().paginationExist();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request can only be called with a positive maxItems param")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void userCanNotGetFavoriteSitesWith0MaxItems() throws Exception
{
restClient.authenticateUser(testUser1).withParams("maxItems=0").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST)
.assertLastError()
.containsErrorKey(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS)
.containsSummary(RestErrorModel.ONLY_POSITIVE_VALUES_MAXITEMS)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request response status code for a high skipCount param is OK (200)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void userCanGetFavoriteSitesWithHighSkipCount() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(testUser1).withParams("skipCount=999999999").withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsEmpty()
.assertThat().paginationField("skipCount").is("999999999");
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify admin gets favorite sites for username with special chars with Rest API and response status is NOT_FOUND (404)")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSitesRequestForPersonIDWithSpecialCharacters() throws Exception
{
String randomData = RandomData.getRandomAlphanumeric();
UserModel userSpecialChars = dataUser.usingAdmin().createUser(randomData + "~!@#$%^&[]{}|\\;':\",./<>", "password");
//setting the encoded text for username
userSpecialChars.setUsername(randomData + "~!%40%23%24%25%5E%26%5B%5D%7B%7D%7C%5C%3B%27%3A%22%2C.%2F%3C%3E");
restClient.authenticateUser(dataUser.getAdminUser()).withCoreAPI().usingUser(userSpecialChars).getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY)
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, randomData + "~!%40%23%24%25%5E%26%5B%5D%7B%7D%7C%5C%3B%27%3A%22%2C.%2F%3C%3E"))
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that user can retrieve the last 2 favorite sites")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void userCanRetrieveLast2FavoriteSites() throws Exception
{
restSiteModelsCollection = restClient.authenticateUser(testUser1).withParams("skipCount=1&maxCount=2").
withCoreAPI().usingAuthUser().getFavoriteSites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModelsCollection.assertThat().entriesListIsNotEmpty()
.assertThat().entriesListCountIs(2)
.assertThat().entriesListContains("id", testSite2.getId())
.assertThat().entriesListContains("id", testSite3.getId());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request applies valid properties param")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSitesRequestWithValidPropertiesParam() throws Exception
{
RestSiteModel restSiteModel = restClient.authenticateUser(testUser1).withParams("properties=title")
.withCoreAPI().usingAuthUser().getFavoriteSites().getOneRandomEntry().onModel();
restClient.assertStatusCodeIs(HttpStatus.OK);
restSiteModel.assertThat().fieldsCount().is(1)
.assertThat().field("title").isNotEmpty();
}
@TestRail(section = { TestGroup.REST_API, TestGroup.PEOPLE }, executionType = ExecutionType.REGRESSION,
description = "Verify that getFavoriteSites request applies invalid properties param")
@Test(groups = { TestGroup.REST_API, TestGroup.PEOPLE, TestGroup.REGRESSION })
public void getFavoriteSitesRequestWithInvalidPropertiesParam() throws Exception
{
restClient.authenticateUser(testUser1).withParams("properties=tas").withCoreAPI().usingAuthUser()
.getFavoriteSites().getOneRandomEntry().onModel().assertThat().fieldsCount().is(0);
restClient.assertStatusCodeIs(HttpStatus.OK);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoriteTests.java
+518
View File
@@ -0,0 +1,518 @@
package org.alfresco.rest.favorites;
import org.alfresco.dataprep.CMISUtil.DocumentType;
import org.alfresco.dataprep.SiteService;
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.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;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
public class GetFavoriteTests extends RestTest
{
private UserModel adminUserModel;
private SiteModel siteModel;
private FolderModel folderModel;
private FileModel fileModel;
private ListUserWithRoles usersWithRoles;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
adminUserModel = dataUser.getAdminUser();
siteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
folderModel = dataContent.usingUser(adminUserModel).usingSite(siteModel).createFolder();
fileModel = dataContent.usingUser(adminUserModel).usingResource(folderModel).createContent(DocumentType.TEXT_PLAIN);
usersWithRoles = dataUser.addUsersWithRolesToSite(siteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer,
UserRole.SiteContributor);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavoriteSite() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavoriteFolder() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavoriteFile() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@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", description = "fails only on environment with tenants")
public void userIsNotAbleToRetrieveFavoriteSiteIfAuthenticationFails() throws Exception
{
UserModel siteManager = usersWithRoles.getOneUserWithRole(UserRole.SiteManager);
siteManager.setPassword("wrongPassword");
restClient.authenticateUser(siteManager).withCoreAPI()
.usingUser(siteManager).getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED)
.assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Admin user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToRetrieveFavoritesSite() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel);
RestPersonFavoritesModel favoriteSite = restClient.withCoreAPI().usingUser(adminUserModel).getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteSite.assertThat().field("targetGuid").is(siteModel.getGuid());
favoriteSite.getTarget().getSite()
.assertThat().field("guid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Admin user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToRetrieveFavoritesFolder() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingUser(adminUserModel).getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Admin user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToRetrieveFavoritesFile() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingUser(adminUserModel).getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Collaborator user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToRetrieveFavoriteSite() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify collaborator user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToRetrieveFavoriteFolder() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify collaborator user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToRetrieveFavoriteFile() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Contributor user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToRetrieveFavoriteSite() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid()); ;
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify contributor user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToRetrieveFavoriteFolder() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify contributor user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToRetrieveFavoriteFile() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Consumer user gets favorite site with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToRetrieveFavorites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favSite = restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favSite.assertThat().field("targetGuid").is(siteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify consumer user gets favorite folder with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToRetrieveFavoriteFolder() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify consumer user gets favorite file with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToRetrieveFavoriteFile() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify user doesn't get favorite site of another user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsNotAbleToRetrieveFavoriteSiteOfAnotherSiteMember() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify user doesn't get favorite site of admin user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsNotAbleToRetrieveFavoritesOfAdminUser() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingUser(adminUserModel).getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, adminUserModel.getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify admin user doesn't get favorite site of another user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsNotAbleToRetrieveFavoritesOfAnotherUser() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI()
.usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES },
executionType = ExecutionType.REGRESSION, description = "Verify get favorite user doesn't have any favorite site, file or folder")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void getFavoriteSiteForUserWithoutAnyFavorites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.RELATIONSHIP_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteManager).getUsername(), siteModel.getGuid()))
.statusCodeIs(HttpStatus.NOT_FOUND)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE)
.containsErrorKey(RestErrorModel.RELATIONSHIP_NOT_FOUND_ERRORKEY);
}
@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.REGRESSION })
public void getFavoriteSiteUsingMe() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).withCoreAPI().usingAuthUser().addSiteToFavorites(siteModel);
RestPersonFavoritesModel favoriteSite = restClient.withCoreAPI().usingMe().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteSite.assertThat().field("targetGuid").is(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.REGRESSION })
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").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES },
executionType = ExecutionType.REGRESSION, description = "Verify get favorite site when person id does't exist")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void getFavoriteSiteWhenPersonIdNotExist() throws Exception {
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);
}
@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.REGRESSION })
public void getFavoriteSiteWithEmptyUserId() throws 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")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void getFavoriteSiteWhenFavoriteIdNotExist() throws Exception {
restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(siteModel);
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).getFavorite("invalidId");
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND).assertLastError()
.containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "invalidId"))
.statusCodeIs(HttpStatus.NOT_FOUND)
.descriptionURLIs(RestErrorModel.RESTAPIEXPLORER)
.stackTraceIs(RestErrorModel.STACKTRACE)
.containsErrorKey(RestErrorModel.ENTITY_NOT_FOUND_ERRORKEY);
}
@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.REGRESSION })
public void verifyRequestForGetFavoriteSiteWithProperties() throws Exception
{
UserModel collaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator);
restClient.authenticateUser(collaborator);
restClient.withCoreAPI().usingUser(collaborator).addSiteToFavorites(siteModel);
RestPersonFavoritesModel favoriteSite = restClient.authenticateUser(collaborator).withParams("properties=targetGuid")
.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteSite.assertThat().field("targetGuid").is(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.REGRESSION })
public void verifyRequestForGetFavoriteSiteWithInvalidProperties() throws Exception
{
UserModel collaborator = usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator);
restClient.authenticateUser(collaborator);
restClient.withCoreAPI().usingUser(collaborator).addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.authenticateUser(collaborator).withParams("properties=tas")
.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().fieldsCount().is(0);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify all values from get favorite rest api for a file")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void verifyRequestFieldsForGetFavoriteFile() throws Exception
{
UserModel contributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
restClient.authenticateUser(contributor);
restClient.withCoreAPI().usingUser(contributor).addFileToFavorites(fileModel);
RestPersonFavoritesModel favoriteFile = restClient.authenticateUser(contributor)
.withCoreAPI().usingAuthUser().getFavorite(fileModel.getNodeRefWithoutVersion());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFile.assertThat().field("targetGuid").is(fileModel.getNodeRefWithoutVersion())
.and().field("target.file.isFile").is("true")
.and().field("target.file.mimeType").is("text/plain")
.and().field("target.file.isFolder").is("false")
.and().field("target.file.createdBy").is(adminUserModel.getUsername())
.and().field("target.file.versionLabel").is("1.0")
.and().field("target.file.name").is(fileModel.getName())
.and().field("target.file.parentId").is(folderModel.getNodeRef())
.and().field("target.file.guid").is(fileModel.getNodeRefWithoutVersion())
.and().field("target.file.modifiedBy").is(adminUserModel.getUsername())
.and().field("target.file.id").is(fileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify all values from get favorite rest api for a site")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void verifyRequestFieldsForGetFavoriteSite() throws Exception
{
UserModel contributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
restClient.authenticateUser(contributor);
restClient.withCoreAPI().usingUser(contributor).addFavoriteSite(siteModel);
RestPersonFavoritesModel favoriteSite = restClient.authenticateUser(contributor)
.withCoreAPI().usingAuthUser().getFavorite(siteModel.getGuid());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteSite.assertThat().field("targetGuid").is(siteModel.getGuid())
.and().field("target.site.role").is(UserRole.SiteContributor.toString())
.and().field("target.site.visibility").is(SiteService.Visibility.PUBLIC.toString())
.and().field("target.site.guid").is(siteModel.getGuid())
.and().field("target.site.description").is(siteModel.getDescription())
.and().field("target.site.id").is(siteModel.getId())
.and().field("target.site.preset").is("site-dashboard")
.and().field("target.site.title").is(siteModel.getTitle());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify all values from get favorite rest api for a folder")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void verifyRequestFieldsForGetFavoriteFolder() throws Exception
{
UserModel contributor = usersWithRoles.getOneUserWithRole(UserRole.SiteContributor);
restClient.authenticateUser(contributor);
restClient.withCoreAPI().usingUser(contributor).addFolderToFavorites(folderModel);
RestPersonFavoritesModel favoriteFolder = restClient.authenticateUser(contributor)
.withCoreAPI().usingAuthUser().getFavorite(folderModel.getNodeRef());
restClient.assertStatusCodeIs(HttpStatus.OK);
favoriteFolder.assertThat().field("targetGuid").is(folderModel.getNodeRef())
.and().field("target.folder.isFile").is("false")
.and().field("target.folder.isFolder").is("true")
.and().field("target.folder.createdBy").is(adminUserModel.getUsername())
.and().field("target.folder.name").is(folderModel.getName())
.and().field("target.folder.guid").is(folderModel.getNodeRef())
.and().field("target.folder.modifiedBy").is(adminUserModel.getUsername())
.and().field("target.folder.id").is(folderModel.getNodeRef());
}
@Bug(id = "MNT-16904")
@TestRail(section = { TestGroup.REST_API,
TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION, description = "Verify the get favorite request for invalid network id")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION, TestGroup.NETWORKS })
public void getFavoriteSiteWithInvalidNetworkId() throws Exception
{
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.REGRESSION, 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);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoritesCoreTests.java
-254
View File
@@ -1,254 +0,0 @@
package org.alfresco.rest.favorites;
import org.alfresco.dataprep.CMISUtil;
import org.alfresco.rest.RestTest;
import org.alfresco.rest.model.RestErrorModel;
import org.alfresco.rest.model.RestPersonFavoritesModelsCollection;
import org.alfresco.utility.constants.UserRole;
import org.alfresco.utility.data.DataUser;
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;
/**
* Created by Claudia Agache on 11/21/2016.
*/
public class GetFavoritesCoreTests extends RestTest
{
private UserModel adminUserModel;
private SiteModel firstSiteModel, secondSiteModel;
private FileModel firstFileModel, secondFileModel;
private FolderModel firstFolderModel, secondFolderModel;
private DataUser.ListUserWithRoles usersWithRoles;
private RestPersonFavoritesModelsCollection userFavorites;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
adminUserModel = dataUser.getAdminUser();
restClient.authenticateUser(adminUserModel);
firstSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
secondSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
firstFolderModel = dataContent.usingUser(adminUserModel).usingSite(firstSiteModel).createFolder();
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);
usersWithRoles = dataUser.addUsersWithRolesToSite(firstSiteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer,
UserRole.SiteContributor);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToRetrieveOnlyFavoritesSites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().where().targetSiteExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites files with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToRetrieveOnlyFavoritesFiles() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().where().targetFileExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites folders with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToRetrieveOnlyFavoritesFolders() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().where().targetFolderExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", firstSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", firstFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites files or folders with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToRetrieveFavoritesFilesOrFolders() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetFolderExist().or().targetFileExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites files or sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToRetrieveFavoritesFilesOrSites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetSiteExist().or().targetFileExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites folders or sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToRetrieveFavoritesFoldersOrSites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetSiteExist().or().targetFolderExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", firstFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets all favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userIsAbleToRetrieveAllFavorites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetSiteExist().or().targetFolderExist().or().targetFileExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion());
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify request using invalid where parameter returns status 400")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void getFavoritesUsingInvalidWhereParameter() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().or().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 request for a user with no favorites returns status 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void userHasNoFavorites() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor));
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListIsEmpty().and().paginationField("totalItems").is("0");
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets correct favorites after deleting a favorite")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void checkFavoriteFolderIsRemoved() throws Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
restClient.withCoreAPI().usingAuthUser().deleteFolderFromFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef())
.and().paginationField("totalItems").is("2");
}
// @Bug(id="REPO-1642", description = "reproduced on 5.2.1 only, it works on 5.2.0")
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify request using personId that does not exist returns status 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.CORE })
public void checkFavoritesWhenPersonIdDoesNotExist() throws Exception
{
UserModel someUser = new UserModel("someUser", DataUser.PASSWORD);
restClient.authenticateUser(adminUserModel).withCoreAPI()
.usingUser(someUser).getFavorites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, "someUser"));
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoritesFullTests.java
-230
View File
@@ -1,230 +0,0 @@
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 for non-tenant user")
@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 for tenant user")
@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
-197
View File
@@ -1,197 +0,0 @@
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.rest.model.RestPersonFavoritesModelsCollection;
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 GetFavoritesSanityTests extends RestTest
{
private UserModel adminUserModel;
private SiteModel firstSiteModel;
private SiteModel secondSiteModel;
private FileModel firstFileModel;
private FileModel secondFileModel;
private FolderModel firstFolderModel;
private FolderModel secondFolderModel;
private ListUserWithRoles usersWithRoles;
private RestPersonFavoritesModelsCollection restPersonFavoritesModelsCollection;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
adminUserModel = dataUser.getAdminUser();
restClient.authenticateUser(adminUserModel);
firstSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
secondSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
firstFolderModel = dataContent.usingUser(adminUserModel).usingSite(firstSiteModel).createFolder();
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);
usersWithRoles = dataUser.addUsersWithRolesToSite(firstSiteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer,
UserRole.SiteContributor);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Admin user gets favorites sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void adminIsAbleToRetrieveFavoritesSites() throws JsonToModelConversionException, Exception
{
restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(secondSiteModel);
restPersonFavoritesModelsCollection = restClient.withCoreAPI().usingAuthUser().where().targetSiteExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restPersonFavoritesModelsCollection.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", secondSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Admin user gets favorites folders with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void adminIsAbleToRetrieveFavoritesFolders() throws JsonToModelConversionException, Exception
{
restClient.withCoreAPI().usingUser(adminUserModel).addFolderToFavorites(firstFolderModel);
restClient.withCoreAPI().usingUser(adminUserModel).addFolderToFavorites(secondFolderModel);
restPersonFavoritesModelsCollection = restClient.withCoreAPI().usingAuthUser().where().targetFolderExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restPersonFavoritesModelsCollection.assertThat().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", secondFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Admin user gets favorites files with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void adminIsAbleToRetrieveFavoritesFiles() throws JsonToModelConversionException, Exception
{
restClient.withCoreAPI().usingUser(adminUserModel).addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingUser(adminUserModel).addFileToFavorites(secondFileModel);
restPersonFavoritesModelsCollection = restClient.withCoreAPI().usingAuthUser().where().targetFileExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restPersonFavoritesModelsCollection.assertThat().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListContains("targetGuid", secondFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavorites() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
restPersonFavoritesModelsCollection = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restPersonFavoritesModelsCollection.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.assertThat().entriesListContains("targetGuid", secondSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Collaborator user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void collaboratorIsAbleToRetrieveFavorites() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
restPersonFavoritesModelsCollection = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restPersonFavoritesModelsCollection.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", secondSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Contributor user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void contributorIsAbleToRetrieveFavorites() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
restPersonFavoritesModelsCollection = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restPersonFavoritesModelsCollection.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid()).and()
.entriesListContains("targetGuid", secondSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Consumer user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void consumerIsAbleToRetrieveFavorites() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
restPersonFavoritesModelsCollection = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
restPersonFavoritesModelsCollection.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.assertThat().entriesListContains("targetGuid", secondSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify user doesn't have permission to get favorites of another user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES })
public void userIsNotAbleToRetrieveFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator)).getFavorites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify user doesn't have permission to get favorites of admin user with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES })
public void userIsNotAbleToRetrieveFavoritesOfAdminUser() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(usersWithRoles.getOneUserWithRole(UserRole.SiteConsumer)).withCoreAPI()
.usingUser(adminUserModel).getFavorites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, adminUserModel.getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify admin user doesn't have permission to get favorites of another user with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES })
public void adminIsNotAbleToRetrieveFavoritesOfAnotherUser() throws JsonToModelConversionException, Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator))
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, usersWithRoles.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@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", description = "It 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)
.assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
}
e2e-test/java/org/alfresco/rest/favorites/GetFavoritesTests.java
+588
View File
@@ -0,0 +1,588 @@
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.rest.model.RestPersonFavoritesModel;
import org.alfresco.rest.model.RestPersonFavoritesModelsCollection;
import org.alfresco.rest.model.RestSiteModel;
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 GetFavoritesTests extends RestTest
{
private UserModel adminUserModel, userModel;
private SiteModel firstSiteModel;
private SiteModel secondSiteModel;
private SiteModel thirdSiteModel;
private FileModel firstFileModel;
private FileModel secondFileModel;
private FolderModel firstFolderModel;
private FolderModel secondFolderModel;
private ListUserWithRoles firstSiteUsers, secondSiteUsers;
private RestPersonFavoritesModelsCollection userFavorites;
@BeforeClass(alwaysRun = true)
public void dataPreparation() throws Exception
{
adminUserModel = dataUser.getAdminUser();
userModel = dataUser.createRandomTestUser();
firstSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
secondSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
thirdSiteModel = dataSite.usingUser(adminUserModel).createPublicRandomSite();
firstFolderModel = dataContent.usingUser(adminUserModel).usingSite(firstSiteModel).createFolder();
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);
firstSiteUsers = dataUser.addUsersWithRolesToSite(firstSiteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer,
UserRole.SiteContributor);
secondSiteUsers = dataUser.addUsersWithRolesToSite(secondSiteModel, UserRole.SiteManager, UserRole.SiteCollaborator, UserRole.SiteConsumer,
UserRole.SiteContributor);
restClient.authenticateUser(userModel);
restClient.withCoreAPI().usingUser(userModel).addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingUser(userModel).addSiteToFavorites(secondSiteModel);
restClient.withCoreAPI().usingUser(userModel).addSiteToFavorites(thirdSiteModel);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.SANITY,
description = "Verify Manager user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.SANITY })
public void managerIsAbleToRetrieveFavorites() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.assertThat().entriesListContains("targetGuid", secondSiteModel.getGuid());
}
@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", description = "It fails only on environment with tenants")
public void userIsNotAbleToRetrieveFavoritesIfAuthenticationFails() throws Exception
{
UserModel siteManager = firstSiteUsers.getOneUserWithRole(UserRole.SiteManager);
siteManager.setPassword("wrongPassword");
restClient.authenticateUser(siteManager).withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.UNAUTHORIZED)
.assertLastError().containsSummary(RestErrorModel.AUTHENTICATION_FAILED);
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Admin user gets favorites sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToRetrieveFavoritesSites() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingUser(adminUserModel).addSiteToFavorites(secondSiteModel);
userFavorites = restClient.withCoreAPI()
.usingAuthUser().where().targetSiteExist().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 Admin user gets favorites folders with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToRetrieveFavoritesFolders() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addFolderToFavorites(firstFolderModel);
restClient.withCoreAPI().usingUser(adminUserModel).addFolderToFavorites(secondFolderModel);
userFavorites = restClient.withCoreAPI()
.usingAuthUser().where().targetFolderExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", secondFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Admin user gets favorites files with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsAbleToRetrieveFavoritesFiles() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(adminUserModel).addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingUser(adminUserModel).addFileToFavorites(secondFileModel);
userFavorites = restClient.withCoreAPI()
.usingAuthUser().where().targetFileExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListContains("targetGuid", secondFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify Collaborator user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void collaboratorIsAbleToRetrieveFavorites() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator))
.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().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 Contributor user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void contributorIsAbleToRetrieveFavorites() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteContributor))
.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().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 Consumer user gets favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void consumerIsAbleToRetrieveFavorites() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(secondSiteModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.assertThat().entriesListContains("targetGuid", secondSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify user doesn't have permission to get favorites of another user with Rest API and status code is 404")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsNotAbleToRetrieveFavoritesOfAnotherUser() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteConsumer))
.withCoreAPI().usingUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator)).getFavorites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, firstSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify user doesn't have permission to get favorites of admin user with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsNotAbleToRetrieveFavoritesOfAdminUser() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteConsumer)).withCoreAPI()
.usingUser(adminUserModel).getFavorites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, adminUserModel.getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify admin user doesn't have permission to get favorites of another user with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void adminIsNotAbleToRetrieveFavoritesOfAnotherUser() throws Exception
{
restClient.authenticateUser(adminUserModel).withCoreAPI().usingUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator))
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.NOT_FOUND)
.assertLastError().containsSummary(String.format(RestErrorModel.ENTITY_NOT_FOUND, firstSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator).getUsername()));
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToRetrieveOnlyFavoritesSites() throws Exception
{
restClient.authenticateUser(secondSiteUsers.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().where().targetSiteExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites files with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToRetrieveOnlyFavoritesFiles() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().where().targetFileExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites folders with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToRetrieveOnlyFavoritesFolders() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().where().targetFolderExist().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", firstSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", firstFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites files or folders with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToRetrieveFavoritesFilesOrFolders() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetFolderExist().or().targetFileExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstSiteModel.getGuid());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites files or sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToRetrieveFavoritesFilesOrSites() throws Exception
{
restClient.authenticateUser(secondSiteUsers.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetSiteExist().or().targetFileExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets only favorites folders or sites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToRetrieveFavoritesFoldersOrSites() throws Exception
{
restClient.authenticateUser(secondSiteUsers.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetSiteExist().or().targetFolderExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", firstFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify User gets all favorites with Rest API and status code is 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userIsAbleToRetrieveAllFavorites() throws Exception
{
restClient.authenticateUser(secondSiteUsers.getOneUserWithRole(UserRole.SiteCollaborator));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().targetSiteExist().or().targetFolderExist().or().targetFileExist()
.getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion());
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListContains("targetGuid", firstSiteModel.getGuid())
.and().entriesListContains("targetGuid", firstFolderModel.getNodeRef())
.and().entriesListContains("targetGuid", firstFileModel.getNodeRefWithoutVersion())
.and().entriesListDoesNotContain("targetGuid", secondSiteModel.getGuid())
.and().entriesListDoesNotContain("targetGuid", secondFolderModel.getNodeRef())
.and().entriesListDoesNotContain("targetGuid", secondFileModel.getNodeRefWithoutVersion());
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify request for a user with no favorites returns status 200")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void userHasNoFavorites() throws Exception
{
restClient.authenticateUser(secondSiteUsers.getOneUserWithRole(UserRole.SiteContributor));
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListIsEmpty().and().paginationField("totalItems").is("0");
}
@TestRail(section = { TestGroup.REST_API, TestGroup.FAVORITES }, executionType = ExecutionType.REGRESSION,
description = "Verify request using invalid where parameter returns status 400")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void getFavoritesUsingInvalidWhereParameter() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteConsumer));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser()
.where().or().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 User gets correct favorites after deleting a favorite")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
public void checkFavoriteFolderIsRemoved() throws Exception
{
restClient.authenticateUser(firstSiteUsers.getOneUserWithRole(UserRole.SiteManager));
restClient.withCoreAPI().usingAuthUser().addSiteToFavorites(firstSiteModel);
restClient.withCoreAPI().usingAuthUser().addFileToFavorites(firstFileModel);
restClient.withCoreAPI().usingAuthUser().addFolderToFavorites(firstFolderModel);
restClient.withCoreAPI().usingAuthUser().deleteFolderFromFavorites(firstFolderModel);
userFavorites = restClient.withCoreAPI().usingAuthUser().getFavorites();
restClient.assertStatusCodeIs(HttpStatus.OK);
userFavorites.assertThat().entriesListDoesNotContain("targetGuid", firstFolderModel.getNodeRef())
.and().paginationField("totalItems").is("2");
}
@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.REGRESSION })
public void userIsAbleToGetFavoritesWhenUsingMeAsUsername() throws Exception
{
userFavorites = restClient.authenticateUser(userModel).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.REGRESSION })
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.REGRESSION })
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.REGRESSION })
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 for non-tenant user")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION })
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.REGRESSION })
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.REGRESSION })
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.REGRESSION })
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.REGRESSION })
public void userIsAbleToGetFavoritesExceptTheFirstOne() throws Exception
{
userFavorites = restClient.authenticateUser(userModel).withParams("skipCount=1").withCoreAPI().usingUser(userModel).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.REGRESSION })
public void userIsAbleToGetFirstTwoFavorites() throws Exception
{
userFavorites = restClient.authenticateUser(userModel).withParams("maxItems=2").withCoreAPI().usingUser(userModel).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.REGRESSION })
public void userIsAbleToGetFavoritesWhenSkipCountAndMaxItemsAreEmpty() throws Exception
{
restClient.authenticateUser(userModel).withParams("skipCount= ").withCoreAPI().usingUser(userModel).getFavorites();
restClient.assertStatusCodeIs(HttpStatus.BAD_REQUEST).assertLastError().containsSummary(String.format(RestErrorModel.INVALID_SKIPCOUNT, " "));
restClient.authenticateUser(userModel).withParams("maxItems= ").withCoreAPI().usingUser(userModel).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 for tenant user")
@Test(groups = { TestGroup.REST_API, TestGroup.FAVORITES, TestGroup.REGRESSION, TestGroup.NETWORKS})
public void getFavoriteSitesWhenNetworkIdIsInvalid() throws 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.REGRESSION })
public void userIsAbleToGetFavoritesWithHighSkipCount() throws Exception
{
userFavorites = restClient.authenticateUser(userModel).withParams("skipCount=999999999").withCoreAPI().usingUser(userModel).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.REGRESSION })
public void userIsAbleToGetFavoritesWithPropertiesParamApplied() throws Exception
{
userFavorites = restClient.authenticateUser(userModel).withParams("properties=targetGuid").withCoreAPI().usingUser(userModel).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.REGRESSION })
@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(userModel).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());
}
}