from cubicweb.devtools.apptest import EnvBasedTC

from cubicweb import ValidationError

    if name is None:

    self.execute('SET WF workflow_of ET WHERE WF eid %(wf)s, ET name %(et)s',

                 {'wf': wf.eid, 'et': etype})

    return wf

def parse_hist(wfhist):

    return [(ti.previous_state.name, ti.new_state.name,

             ti.transition and ti.transition.name, ti.comment)

            for ti in wfhist]

class WorkflowBuildingTC(EnvBasedTC):

    def test_wf_construction(self):

        wf = add_wf(self, 'Company')

        foo = wf.add_state(u'foo', initial=True)

        bar = wf.add_state(u'bar')

        self.assertEquals(wf.state_by_name('bar').eid, bar.eid)

        self.assertEquals(wf.state_by_name('barrr'), None)

        baz = wf.add_transition(u'baz', (foo,), bar, ('managers',))

        self.assertEquals(wf.transition_by_name('baz').eid, baz.eid)

        self.assertEquals(len(baz.require_group), 1)

        self.assertEquals(baz.require_group[0].name, 'managers')

    def test_duplicated_state(self):

        wf = add_wf(self, 'Company')

        wf.add_state(u'foo', initial=True)

        self.commit()

        wf.add_state(u'foo')

        ex = self.assertRaises(ValidationError, self.commit)

        # XXX enhance message

        self.assertEquals(ex.errors, {'state_of': 'unique constraint S name N, Y state_of O, Y name N failed'})

        # no pb if not in the same workflow

        wf2 = add_wf(self, 'Company')

        foo = wf2.add_state(u'foo', initial=True)

        self.commit()

    def test_duplicated_transition(self):

        wf = add_wf(self, 'Company')

        foo = wf.add_state(u'foo', initial=True)

        bar = wf.add_state(u'bar')

        wf.add_transition(u'baz', (foo,), bar, ('managers',))

        wf.add_transition(u'baz', (bar,), foo)

        ex = self.assertRaises(ValidationError, self.commit)

        # XXX enhance message

        self.assertEquals(ex.errors, {'transition_of': 'unique constraint S name N, Y transition_of O, Y name N failed'})

class WorkflowTC(EnvBasedTC):

    def setup_database(self):

        rschema = self.schema['in_state']

        for x, y in rschema.iter_rdefs():

            self.assertEquals(rschema.rproperty(x, y, 'cardinality'), '1*')

        self.member = self.create_user('member')

    def test_workflow_base(self):

        e = self.create_user('toto')

        self.assertEquals(e.state, 'activated')

        e.change_state('deactivated', u'deactivate 1')

        self.commit()

        e.change_state('activated', u'activate 1')

        self.commit()

        e.change_state('deactivated', u'deactivate 2')

        self.commit()

        e.clear_related_cache('wf_info_for', 'object')

        self.assertEquals([tr.comment for tr in e.reverse_wf_info_for],

                          ['deactivate 1', 'activate 1', 'deactivate 2'])

        self.assertEquals(e.latest_trinfo().comment, 'deactivate 2')

    def test_possible_transitions(self):

        user = self.entity('CWUser X')

        trs = list(user.possible_transitions())

        self.assertEquals(len(trs), 1)

        self.assertEquals(trs[0].name, u'deactivate')

        self.assertEquals(trs[0].destination().name, u'deactivated')

        # test a std user get no possible transition

        cnx = self.login('member')

        # fetch the entity using the new session

        trs = list(cnx.user().possible_transitions())

        self.assertEquals(len(trs), 0)

    def _test_manager_deactivate(self, user):

        user.clear_related_cache('in_state', 'subject')

        self.assertEquals(len(user.in_state), 1)

        self.assertEquals(user.state, 'deactivated')

        trinfo = user.latest_trinfo()

        self.assertEquals(trinfo.previous_state.name, 'activated')

        self.assertEquals(trinfo.new_state.name, 'deactivated')

        self.assertEquals(trinfo.comment, 'deactivate user')

        self.assertEquals(trinfo.comment_format, 'text/plain')

        return trinfo

    def test_change_state(self):

        user = self.user()

        user.change_state('deactivated', comment=u'deactivate user')

        trinfo = self._test_manager_deactivate(user)

        self.assertEquals(trinfo.transition, None)

    def test_set_in_state_bad_wf(self):

        wf = add_wf(self, 'CWUser')

        s = wf.add_state(u'foo', initial=True)

        self.commit()

        ex = self.assertRaises(ValidationError, self.session().unsafe_execute,

                               'SET X in_state S WHERE X eid %(x)s, S eid %(s)s',

                               {'x': self.user().eid, 's': s.eid}, 'x')

        self.assertEquals(ex.errors, {'in_state': "state doesn't belong to entity's workflow. "

                                      "You may want to set a custom workflow for this entity first."})

    def test_fire_transition(self):

        user = self.user()

        user.fire_transition('deactivate', comment=u'deactivate user')

        user.clear_all_caches()

        self.assertEquals(user.state, 'deactivated')

        self._test_manager_deactivate(user)

        trinfo = self._test_manager_deactivate(user)

        self.assertEquals(trinfo.transition.name, 'deactivate')

    # XXX test managers can change state without matching transition

    def _test_stduser_deactivate(self):

        ueid = self.member.eid

        self.create_user('tutu')

        cnx = self.login('tutu')

        req = self.request()

        member = req.entity_from_eid(self.member.eid)

        ex = self.assertRaises(ValidationError,

                               member.fire_transition, 'deactivate')

        self.assertEquals(ex.errors, {'by_transition': "transition may not be fired"})

        cnx.close()

        cnx = self.login('member')

        req = self.request()

        member = req.entity_from_eid(self.member.eid)

        member.fire_transition('deactivate')

        cnx.commit()

        ex = self.assertRaises(ValidationError,

                               member.fire_transition, 'activate')

        self.assertEquals(ex.errors, {'by_transition': "transition may not be fired"})

    def test_fire_transition_owned_by(self):

        self.execute('INSERT RQLExpression X: X exprtype "ERQLExpression", '

                     'X expression "X owned_by U", T condition X '

                     'WHERE T name "deactivate"')

        self._test_stduser_deactivate()

    def test_fire_transition_has_update_perm(self):

        self.execute('INSERT RQLExpression X: X exprtype "ERQLExpression", '

                     'X expression "U has_update_permission X", T condition X '

                     'WHERE T name "deactivate"')

        self._test_stduser_deactivate()

class CustomWorkflowTC(EnvBasedTC):

    def setup_database(self):

        self.member = self.create_user('member')

    def tearDown(self):

        super(CustomWorkflowTC, self).tearDown()

        self.execute('DELETE X custom_workflow WF')

    def test_custom_wf_replace_state_no_history(self):

        """member in inital state with no previous history, state is simply

        redirected when changing workflow

        """

        wf = add_wf(self, 'CWUser')

        wf.add_state('asleep', initial=True)

        self.execute('SET X custom_workflow WF WHERE X eid %(x)s, WF eid %(wf)s',

                     {'wf': wf.eid, 'x': self.member.eid})

        self.member.clear_all_caches()

        self.assertEquals(self.member.state, 'activated')# no change before commit

        self.commit()

        self.member.clear_all_caches()

        self.assertEquals(self.member.current_workflow.eid, wf.eid)

        self.assertEquals(self.member.state, 'asleep')

        self.assertEquals(self.member.workflow_history, [])

    def test_custom_wf_replace_state_keep_history(self):

        """member in inital state with some history, state is redirected and

        state change is recorded to history

        """

        self.member.fire_transition('deactivate')

        self.member.fire_transition('activate')

        wf = add_wf(self, 'CWUser')

        wf.add_state('asleep', initial=True)

        self.execute('SET X custom_workflow WF WHERE X eid %(x)s, WF eid %(wf)s',

                     {'wf': wf.eid, 'x': self.member.eid})

        self.commit()

        self.member.clear_all_caches()

        self.assertEquals(self.member.current_workflow.eid, wf.eid)

        self.assertEquals(self.member.state, 'asleep')

        self.assertEquals(parse_hist(self.member.workflow_history),

                          [('activated', 'deactivated', 'deactivate', None),

                           ('deactivated', 'activated', 'activate', None),

                           ('activated', 'asleep', None, 'workflow changed to "CWUser"')])

    def test_custom_wf_no_initial_state(self):

        """try to set a custom workflow which has no initial state"""

        self.member.fire_transition('deactivate')

        wf = add_wf(self, 'CWUser')

        wf.add_state('asleep')

        self.execute('SET X custom_workflow WF WHERE X eid %(x)s, WF eid %(wf)s',

                     {'wf': wf.eid, 'x': self.member.eid})

        ex = self.assertRaises(ValidationError, self.commit)

        self.assertEquals(ex.errors, {'custom_workflow': u'workflow has no initial state'})

    def test_custom_wf_bad_etype(self):

        """try to set a custom workflow which doesn't apply to entity type"""

        wf = add_wf(self, 'Company')

        wf.add_state('asleep', initial=True)

        self.execute('SET X custom_workflow WF WHERE X eid %(x)s, WF eid %(wf)s',

                     {'wf': wf.eid, 'x': self.member.eid})

        ex = self.assertRaises(ValidationError, self.commit)

        self.assertEquals(ex.errors, {'custom_workflow': 'constraint S is ET, O workflow_of ET failed'})

    def test_del_custom_wf(self):

        """member in some state shared by the new workflow, nothing has to be

        done

        """

        self.member.fire_transition('deactivate')

        wf = add_wf(self, 'CWUser')

        wf.add_state('asleep', initial=True)

        self.execute('SET X custom_workflow WF WHERE X eid %(x)s, WF eid %(wf)s',

                     {'wf': wf.eid, 'x': self.member.eid})

        self.commit()

        self.execute('DELETE X custom_workflow WF WHERE X eid %(x)s, WF eid %(wf)s',

                     {'wf': wf.eid, 'x': self.member.eid})

        self.member.clear_all_caches()

        self.assertEquals(self.member.state, 'asleep')# no change before commit

        self.commit()

        self.member.clear_all_caches()

        self.assertEquals(self.member.current_workflow.name, "CWUser workflow")

        self.assertEquals(self.member.state, 'activated')

        self.assertEquals(parse_hist(self.member.workflow_history),