/src/main/resources/com/onresolve/jira/groovy/test/TestRenameUser.groovy

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)

    }

}