/src/main/resources/com/onresolve/jira/groovy/test/TestRenameUser.groovy
Groovy | 365 lines | 301 code | 53 blank | 11 comment | 10 complexity | 17c38b710966a7f2e68b4f09ccf68c4e MD5 | raw file
- package com.onresolve.jira.groovy.test
- import com.atlassian.core.action.ActionUtils
- import com.atlassian.core.ofbiz.CoreFactory
- import com.atlassian.jira.ComponentManager
- import com.atlassian.jira.ManagerFactory
- import com.atlassian.jira.action.ActionNames
- import com.atlassian.jira.bc.JiraServiceContextImpl
- import com.atlassian.jira.bc.filter.SearchRequestService
- import com.atlassian.jira.bc.user.UserService
- import com.atlassian.jira.bc.user.UserService.DeleteUserValidationResult
- import com.atlassian.jira.favourites.FavouritesManager
- import com.atlassian.jira.issue.CustomFieldManager
- import com.atlassian.jira.issue.Issue
- import com.atlassian.jira.issue.IssueManager
- import com.atlassian.jira.issue.customfields.impl.MultiUserCFType
- import com.atlassian.jira.issue.customfields.impl.UserCFType
- import com.atlassian.jira.issue.fields.CustomField
- import com.atlassian.jira.issue.search.SearchRequest
- import com.atlassian.jira.issue.watchers.WatcherManager
- import com.atlassian.jira.jql.builder.JqlQueryBuilder
- import com.atlassian.jira.jql.parser.JqlQueryParser
- import com.atlassian.jira.project.Project
- import com.atlassian.jira.security.roles.actor.UserRoleActorFactory
- import com.atlassian.jira.sharing.ShareManager
- import com.atlassian.jira.sharing.SharedEntity.SharePermissions
- import com.atlassian.query.Query
- import com.atlassian.query.order.SortOrder
- import com.onresolve.jira.groovy.canned.admin.RenameUser
- import org.apache.log4j.Category
- import org.junit.Before
- import org.junit.Test
- import org.ofbiz.core.entity.GenericValue
- import webwork.dispatcher.ActionResult
- import com.atlassian.jira.security.roles.*
- import static junit.framework.Assert.*
- import com.atlassian.jira.issue.search.SearchProvider
- import com.atlassian.jira.web.bean.PagerFilter
- import com.atlassian.jira.issue.search.SearchResults
- import com.atlassian.jira.bc.user.UserService.CreateUserValidationResult
- import com.atlassian.jira.bc.group.GroupService
- import com.atlassian.crowd.embedded.api.User
- import com.atlassian.jira.user.util.UserUtil
- import com.atlassian.jira.security.groups.GroupManager
- import com.onresolve.jira.groovy.GroovyRunner
- class TestRenameUser {
- Category log = Category.getInstance(this.class)
- RenameUser renameUser
- ComponentManager componentManager = ComponentManager.getInstance()
- CustomFieldManager customFieldManager = componentManager.getCustomFieldManager()
- JqlQueryBuilder builder = JqlQueryBuilder.newBuilder()
- JqlQueryParser jqlQueryParser = ComponentManager.getComponentInstanceOfType(JqlQueryParser.class) as JqlQueryParser
- final String sourceUser = "def"
- final String targetUser = "abc"
- SearchRequestService searchRequestService = componentManager.getSearchRequestService()
- User currentUser = componentManager.getJiraAuthenticationContext().getUser()
- IssueManager issueManager = ManagerFactory.getIssueManager()
- Project project = componentManager.getProjectManager().getProjectObjByKey('JRA')
- GroovyRunner runner = new GroovyRunner()
- UserUtil userUtil = ComponentManager.getInstance().getUserUtil()
- FavouritesManager favouritesManager = ComponentManager.getComponentInstanceOfType(FavouritesManager.class) as FavouritesManager
- ShareManager shareManager = ComponentManager.getComponentInstanceOfType(ShareManager.class) as ShareManager
- SearchProvider searchProvider = componentManager.getSearchProvider()
- UserService userService = ComponentManager.getComponentInstanceOfType(UserService.class) as UserService
- GroupService groupService = ComponentManager.getComponentInstanceOfType(GroupService.class) as GroupService
- GroupManager groupManager = ComponentManager.getComponentInstanceOfType(GroupManager.class)
- @Before
- public void setUp() {
- renameUser = new RenameUser()
- log.debug("===================================================================================================")
- // check group exists
- userUtil.getGroup("SomeGroup")
- ["xxx", "yyy"].each {String u ->
- if (userUtil.getUser(u)) {
- log.debug("Deleting user: $u")
- builder.clear()
- Query query = builder.where().reporterUser(u).or().assigneeUser(u).buildQuery()
- SearchResults results = searchProvider.search(query, currentUser, PagerFilter.getUnlimitedFilter())
- results.getIssues().each {Issue issue ->
- log.debug("Delete issue $issue.key")
- deleteIssue(issueManager.getIssueObject(issue.id))
- }
- deleteUser(userUtil.getUser(u))
- }
- }
- }
- @Test
- public void testUpdateSearchRequest() {
- builder.clear()
- Query query = builder.where().reporterUser(sourceUser).buildQuery()
- query = JqlQueryBuilder.newBuilder(query).orderBy().assignee(SortOrder.ASC).buildQuery()
- SearchRequest sr = new SearchRequest(query, currentUser.getName(), "ReporterIsDef", "some desc")
- sr = createAndUpdate(sr)
- assertEquals '{reporter = "abc"} order by assignee ASC', sr.query.toString()
- deleteSearchRequest(sr)
- // this query should not need to be updated
- builder.clear()
- query = builder.where().reporterUser("admin").buildQuery()
- sr = new SearchRequest(query, currentUser.getName(), "ReporterIsDef", "some desc")
- sr = createAndUpdate(sr)
- log.debug(sr.query.queryString)
- deleteSearchRequest(sr)
- }
- private void deleteSearchRequest (SearchRequest sr) {
- JiraServiceContextImpl ctx = new JiraServiceContextImpl(userUtil.getUser(sr.ownerUserName))
- searchRequestService.deleteFilter(ctx, sr.id)
- assertFalse ctx.errorCollection.hasAnyErrors()
- }
- private SearchRequest createAndUpdate(SearchRequest sr) {
- JiraServiceContextImpl ctx = new JiraServiceContextImpl(currentUser)
- searchRequestService.validateFilterForCreate(ctx, sr)
- assertFalse ctx.errorCollection.hasAnyErrors()
- sr = searchRequestService.createFilter(ctx, sr, true)
- assertFalse ctx.errorCollection.hasAnyErrors()
- renameUser.updateSingleRequest(sr, sourceUser, targetUser)
- sr = searchRequestService.getFilter(ctx, sr.id)
- sr
- }
- @Test
- public void testTransformQuery() {
- log.debug("testTransformQuery")
- Query query, transformedQuery
- CustomField cfUserPicker = customFieldManager.getCustomFieldObjectByName("UserPicker")
- CustomField cfMultiUserPicker = customFieldManager.getCustomFieldObjectByName("MultiUserPicker")
- assertNotNull cfUserPicker
- assertNotNull cfMultiUserPicker
- log.debug(cfMultiUserPicker.getCustomFieldType().class)
- assertTrue (cfUserPicker.getCustomFieldType() instanceof UserCFType)
- assertTrue (cfMultiUserPicker.getCustomFieldType() instanceof MultiUserCFType)
- query = builder.where().reporterUser('def').buildQuery()
- query = JqlQueryBuilder.newBuilder(query).orderBy().assignee(SortOrder.ASC).buildQuery()
- assertEquals "{reporter = \"def\"} order by assignee ASC", query.toString()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals "{reporter = \"abc\"} order by assignee ASC", transformedQuery.toString()
- builder.clear()
- query = builder.where().reporterUser('def').and().assigneeUser("def").buildQuery()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals '{reporter = "abc"} AND {assignee = "abc"}', transformedQuery.toString()
- builder.clear()
- query = builder.where().reporter().in().strings("admin", "def").buildQuery()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals '{reporter in ("admin", "abc")}', transformedQuery.toString()
- builder.clear()
- query = builder.where().reporter().notIn().strings("admin", "def").buildQuery()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals '{reporter not in ("admin", "abc")}', transformedQuery.toString()
- builder.clear()
- query = builder.where().reporter().notEq("def").buildQuery()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals '{reporter != "abc"}', transformedQuery.toString()
- builder.clear()
- query = builder.where().sub().reporter().eq("def").or().priority("1").endsub().and().sub().reporterUser("admin").or().priority("2").endsub().buildQuery()
- assertEquals '( {reporter = "def"} OR {priority = "1"} ) AND ( {reporter = "admin"} OR {priority = "2"} )', query.toString()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals '( {reporter = "abc"} OR {priority = "1"} ) AND ( {reporter = "admin"} OR {priority = "2"} )', transformedQuery.toString()
- builder.clear()
- query = builder.where().not().reporter().eq("def").buildQuery()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals 'NOT {reporter = "abc"}', transformedQuery.toString()
- builder.clear()
- query = builder.where().not().sub().reporter().eq("def").or().priority("1").endsub()
- .and().not().sub().reporterUser("admin").or().priority("2").endsub().buildQuery()
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- assertEquals 'NOT ( {reporter = "abc"} OR {priority = "1"} ) AND NOT ( {reporter = "admin"} OR {priority = "2"} )', transformedQuery.toString()
- // custom fields
- builder.clear()
- query = builder.where().customField(cfUserPicker.idAsLong).eq("def").buildQuery()
- log.debug query
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- log.debug(transformedQuery)
- assertEquals '{cf[10040] = "abc"}', transformedQuery.toString()
- // There are two UserPickers, how is it supposed to know which is which
- // Do we want two user pickers for these tests?
- query = jqlQueryParser.parseQuery("UserPicker is def")
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- log.debug(transformedQuery)
- assertEquals '{UserPicker is "abc"}', transformedQuery.toString()
- query = jqlQueryParser.parseQuery("UserPicker IN (admin, def)")
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- log.debug(transformedQuery)
- assertEquals '{UserPicker in ("admin", "abc")}', transformedQuery.toString()
- query = jqlQueryParser.parseQuery("project = JRA AND MultiUserPicker in (def,admin)")
- log.debug(query.queryString)
- transformedQuery = renameUser.transformSearchRequest(query, "def", "abc")
- log.debug(transformedQuery)
- assertEquals '{project = "JRA"} AND {MultiUserPicker in ("abc", "admin")}', transformedQuery.toString()
- }
- @Test
- public void testRename() {
- testDoScript(false)
- }
- @Test
- public void testMerge() {
- testDoScript(true)
- }
- public void testDoScript(boolean merge) {
- log.debug('testDoScript')
- User userSrc = createUser("xxx")
- User userTarget = null
- if (merge) {
- userTarget = createUser("yyy")
- }
- groupManager.addUserToGroup(userSrc, userUtil.getGroup("SomeGroup"))
- GenericValue issueGv1 = createIssue(userSrc);
- GenericValue issueGv2 = null
- if (merge) {
- issueGv2 = createIssue(userTarget);
- }
- builder.clear()
- Query query = builder.where().reporterUser(userSrc.name).buildQuery()
- query = JqlQueryBuilder.newBuilder(query).orderBy().assignee(SortOrder.ASC).buildQuery()
- SearchRequest sr = new SearchRequest(query, userSrc.name, "ReporterIsXXDef", "some desc")
- sr.setPermissions(SharePermissions.GLOBAL)
- JiraServiceContextImpl ctx = new JiraServiceContextImpl(userSrc)
- searchRequestService.validateFilterForCreate(ctx, sr)
- log.debug(ctx.errorCollection)
- assertFalse ctx.errorCollection.hasAnyErrors()
- sr = searchRequestService.createFilter(ctx, sr, true)
- assertFalse ctx.errorCollection.hasAnyErrors()
- favouritesManager.addFavourite(userSrc, sr)
- if (merge) {
- favouritesManager.addFavourite(userTarget, sr)
- }
- WatcherManager watcherManager = componentManager.getWatcherManager()
- watcherManager.startWatching(userSrc, issueGv1)
- if (merge) {
- watcherManager.startWatching(userSrc, issueGv2)
- watcherManager.startWatching(userTarget, issueGv1)
- }
- ProjectRoleManager projectRoleManager = ComponentManager.getComponentInstanceOfType(ProjectRoleManager.class) as ProjectRoleManager
- RoleActorFactory roleActorFactory = ComponentManager.getComponentInstanceOfType(RoleActorFactory.class) as RoleActorFactory
- ProjectRole devsRole = projectRoleManager.getProjectRole("Developers")
- ProjectRoleActors actors = projectRoleManager.getProjectRoleActors(devsRole, project)
- RoleActor roleActor = roleActorFactory.createRoleActor(null, devsRole.id, project.id, UserRoleActorFactory.TYPE, userSrc.name);
- actors = actors.addRoleActor(roleActor) as ProjectRoleActors
- if (merge) {
- roleActor = roleActorFactory.createRoleActor(null, devsRole.id, project.id, UserRoleActorFactory.TYPE, userTarget.name);
- actors = actors.addRoleActor(roleActor) as ProjectRoleActors
- }
- projectRoleManager.updateProjectRoleActors(actors)
- assertTrue projectRoleManager.getProjectRoleActors(devsRole, project).getUsers()*.name.contains(userSrc.name)
- Map<String, Object> inputs = [
- (RenameUser.FIELD_FROM_USER_ID) : userSrc.name,
- (RenameUser.FIELD_TO_USER_ID): (merge ? userTarget.name : "yyy"),
- (RenameUser.FIELD_MERGE): merge,
- ] as Map<String, Object>
- log.debug(inputs)
- Map params = new RenameUser().doScript(inputs)
- userTarget = userUtil.getUser("yyy")
- // post-script assertions
- if (merge) {
- assertEquals "Mr yyy", userTarget.displayName
- }
- assertNull userUtil.getUser(userSrc.name)
- assertNotNull userUtil.getUser(userTarget.name)
- assertTrue groupManager.isUserInGroup(userTarget.name, "SomeGroup")
- assertTrue projectRoleManager.getProjectRoleActors(devsRole, project).getUsers()*.name.contains(userTarget.name)
- assertFalse projectRoleManager.getProjectRoleActors(devsRole, project).getUsers()*.name.contains(userSrc.name)
- assertTrue watcherManager.isWatching(userTarget, issueGv1)
- if (merge) {
- assertTrue watcherManager.isWatching(userTarget, issueGv2)
- }
- // reload sr because the owner has changed now
- sr = searchRequestService.getFilter(new JiraServiceContextImpl(userTarget), sr.id)
- // check that the favourite count has been reduced now these two are the same user
- assertEquals(1, sr.getFavouriteCount())
- // post-script clean-up
- Issue issue = issueManager.getIssueObject(issueGv1.getLong("id"))
- assertEquals userTarget.name, issue.reporterId
- // deleteUser(userSrc)
- deleteIssue(issueManager.getIssueObject(issueGv1.getLong("id")))
- if (merge) {
- deleteIssue(issueManager.getIssueObject(issueGv2.getLong("id")))
- }
- deleteUser(userTarget)
- // don't deleteSearchRequest(sr) because it's handled when the user is deleted properly
- }
- private GenericValue createIssue(User user) {
- Issue issue = componentManager.getIssueFactory().getIssue()
- issue.setProject(project.getGenericValue())
- issue.setSummary "my summary"
- issue.setReporterId user.name
- issue.setIssueTypeId "1"
- issue.setPriorityId('2')
- GenericValue issueGv = issueManager.createIssue(user, issue)
- return issueGv
- }
- private def deleteUser(User user) {
- DeleteUserValidationResult validationResult = userService.validateDeleteUser(componentManager.getJiraAuthenticationContext().getUser(), user.name)
- log.debug(validationResult.errorCollection)
- assertTrue validationResult.isValid()
- userService.removeUser(user, validationResult)
- assertNull userUtil.getUser(user.name)
- }
- private User createUser(String userId) {
- assertNull userUtil.getUser(userId)
- CreateUserValidationResult res = userService.validateCreateUserForAdmin(currentUser, userId, "pw", "pw", "${userId}@blah.com", "Mr ${userId}")
- assertFalse res.errorCollection.hasAnyErrors()
- User user = userService.createUserNoNotification(res)
- assertNotNull userUtil.getUser(userId)
- return user
- }
- public def deleteIssue(Issue theIssue) {
- Map parameters = [
- issue: theIssue.getGenericValue(),
- remoteUser: userUtil.getUser("admin"),
- dispatchEvent: false,
- permissionOverride: true,
- ]
- ActionResult aResult = CoreFactory.getActionDispatcher().execute(ActionNames.ISSUE_DELETE, parameters);
- ActionUtils.checkForErrors(aResult)
- }
- }