##############################################################################
#
# Copyright (c) 2010 Nexedi SA and Contributors. All Rights Reserved.
#          Fabien Morin <fabien@nexedi.com>
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# garantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
##############################################################################

import unittest
from Products.ERP5Type.tests.utils import reindex
from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
from Products.ERP5Type.tests.utils import DummyMailHost
from Products.ERP5Type.tests.Sequence import SequenceList
import email, re
from email.Header import decode_header, make_header
from email.Utils import parseaddr
import transaction
import cgi
from urlparse import urlparse

use_verbose_security = 0
if use_verbose_security:
  import AccessControl
  AccessControl.Implementation.setImplementation('python')
  AccessControl.ImplPython.setDefaultBehaviors(
              ownerous=True,
              authenticated=True,
              verbose=True)


class TestERP5Credential(ERP5TypeTestCase):

  def getTitle(self):
    return "ERP5 Credential"

  def getBusinessTemplateList(self):
    return (
      'erp5_full_text_myisam_catalog',
      'erp5_core_proxy_field_legacy',
      'erp5_base',
      'erp5_jquery',
      'erp5_ingestion_mysql_innodb_catalog',
      'erp5_ingestion',
      'erp5_web',
      'erp5_crm',
      'erp5_credential',
      'erp5_administration')

  def afterSetUp(self):
    """Prepare the test."""
    self.createCategories()
    self.enableAlarm()
    self.validateNotificationMessages()
    # add a dummy mailhost not to send real messages
    if 'MailHost' in self.portal.objectIds():
      self.portal.manage_delObjects(['MailHost'])
    self.portal._setObject('MailHost', DummyMailHost('MailHost'))

  @reindex
  def enableAlarm(self):
    """activate the alarm"""
    portal = self.getPortalObject()
    alarm = portal.portal_alarms.accept_submitted_credentials
    if not alarm.isEnabled():
      alarm.setEnabled(True)

  def validateNotificationMessages(self):
    '''validate all notification messages'''
    portal = self.getPortalObject()
    notification_message_module = portal.getDefaultModule('Notification Message')
    for notification_message in notification_message_module.contentValues():
      if notification_message.getValidationState() == 'draft':
        notification_message.validate()

  @reindex
  def createCategories(self):
    """Create the categories for our test. """
    # create categories
    for cat_string in self.getNeededCategoryList():
      base_cat = cat_string.split("/")[0]
      # if base_cat not exist, create it
      if getattr(self.getPortal().portal_categories, base_cat, None) == None:
        self.getPortal().portal_categories.newContent(\
                                          portal_type='Base Category',
                                          id=base_cat)
      base_cat_value = self.getPortal().portal_categories[base_cat]
      for cat in cat_string.split("/")[1:]:
        if not cat in base_cat_value.objectIds():
          base_cat_value = base_cat_value.newContent(
                    portal_type='Category',
                    id=cat,
                    title=cat.replace('_', ' ').title(),)
        else:
          base_cat_value = base_cat_value[cat]
    # check categories have been created
    for cat_string in self.getNeededCategoryList():
      self.assertNotEquals(None,
                self.getCategoryTool().restrictedTraverse(cat_string),
                cat_string)

  def getNeededCategoryList(self):
    """return a list of categories that should be created."""
    return ('role/client/distributor',
            'role/internal',
            'role/media',
            'role/partner',
            'function/member',
            'function/manager',
            'function/agent',
            'site/dakar',
            'site/paris',
            'site/tokyo',
           )

  def beforeTearDown(self):
    self.login()
    transaction.abort()
    # clear modules if necessary
    module_list = (self.portal.getDefaultModule('Credential Request'),
        self.portal.getDefaultModule('Credential Update'),
        self.portal.getDefaultModule('Credential Recovery'),
        self.portal.getDefaultModule('Person'))
    for module in module_list:
      module.manage_delObjects(list(module.objectIds()))
    self.resetCredentialSystemPreference()
    transaction.commit()
    self.tic()
    self.logout()

  def resetCredentialSystemPreference(self):
    self.login()
    preference = self._getPreference()
    preference.edit(preferred_credential_request_automatic_approval=False,
                    preferred_credential_recovery_automatic_approval=False,
                    preferred_organisation_credential_update_automatic_approval=False,
                    preferred_person_credential_update_automatic_approval=False,
                    preferred_credential_alarm_automatic_call=False)
    self._enablePreference()

  # Copied from bt5/erp5_egov/TestTemplateItem/testEGovMixin.py
  def decode_email(self, file):
    # Prepare result
    theMail = {
      'attachment_list': [],
      'body': '',
      # Place all the email header in the headers dictionary in theMail
      'headers': {}
    }
    # Get Message
    msg = email.message_from_string(file)
    # Back up original file
    theMail['__original__'] = file
    # Recode headers to UTF-8 if needed
    for key, value in msg.items():
      decoded_value_list = decode_header(value)
      unicode_value = make_header(decoded_value_list)
      new_value = unicode_value.__unicode__().encode('utf-8')
      theMail['headers'][key.lower()] = new_value
    # Filter mail addresses
    for header in ('resent-to', 'resent-from', 'resent-cc', 'resent-sender',
                   'to', 'from', 'cc', 'sender', 'reply-to'):
      header_field = theMail['headers'].get(header)
      if header_field:
          theMail['headers'][header] = parseaddr(header_field)[1]
    # Get attachments
    body_found = 0
    for part in msg.walk():
      content_type = part.get_content_type()
      file_name = part.get_filename()
      # multipart/* are just containers
      # XXX Check if data is None ?
      if content_type.startswith('multipart'):
        continue
      # message/rfc822 contains attached email message
      # next 'part' will be the message itself
      # so we ignore this one to avoid doubling
      elif content_type == 'message/rfc822':
        continue
      elif content_type in ("text/plain", "text/html"):
        charset = part.get_content_charset()
        payload = part.get_payload(decode=True)
        #LOG('CMFMailIn -> ',0,'charset: %s, payload: %s' % (charset,payload))
        if charset:
          payload = unicode(payload, charset).encode('utf-8')
        if body_found:
          # Keep the content type
          theMail['attachment_list'].append((file_name,
                                             content_type, payload))
        else:
          theMail['body'] = payload
          body_found = 1
      else:
        payload = part.get_payload(decode=True)
        # Keep the content type
        theMail['attachment_list'].append((file_name, content_type,
                                           payload))
    return theMail

  def _getPreference(self):
    portal_preferences = self.getPreferenceTool()
    preference = getattr(portal_preferences, 'test_site_preference', None)
    if preference is None:
      preference = portal_preferences.newContent(portal_type='System Preference',
                                title='Default Site Preference',
                                id='test_site_preference')
    return preference

  def _enablePreference(self):
    preference = self._getPreference()
    if preference.getPreferenceState() == 'disabled':
      preference.enable()

  def _disablePreference(self):
    preference = self._getPreference()
    if preference.getPreferenceState() in ('enable', 'global'):
      preference.disable()

  def stepSetCredentialRequestAutomaticApprovalPreferences(self, sequence=None):
    self.login()
    preference = self._getPreference()
    automatic_call = sequence.get("automatic_call", True)
    preference.edit(preferred_credential_request_automatic_approval=True,
                    preferred_credential_alarm_automatic_call=automatic_call)
    self._enablePreference()
    self.stepTic()
    self.logout()

  def stepSetCredentialAssignmentPropertyList(self, sequence={}):
    category_list = sequence.get("category_list",
        ["role/internal", "function/member"])
    self.login()
    preference = self._getPreference()
    preference.edit(preferred_subscription_assignment_category_list=category_list)
    self._enablePreference()
    self.stepTic()
    self.logout()

  def stepSetOrganisationCredentialUpdateAutomaticApprovalPreferences(self,
      sequence=None, sequence_list=None, **kw):
    self.login()
    preference = self._getPreference()
    preference.edit(preferred_organisation_credential_update_automatic_approval=True)
    self._enablePreference()
    transaction.commit()
    self.tic()
    self.logout()

  def stepSetCredentialRecoveryAutomaticApprovalPreferences(self, sequence=None,
      sequence_list=None, **kw):
    self.login()
    preference = self._getPreference()
    preference.edit(preferred_credential_recovery_automatic_approval=True)
    self._enablePreference()
    transaction.commit()
    self.tic()
    self.logout()

  def stepSetPersonCredentialUpdateAutomaticApprovalPreferences(self, sequence=None,
      sequence_list=None, **kw):
    self.login()
    preference = self._getPreference()
    preference.edit(preferred_person_credential_update_automatic_approval=True)
    self._enablePreference()
    transaction.commit()
    self.tic()
    self.logout()

  def stepCheckAssignmentAfterActiveLogin(self, sequence):
    portal_catalog = self.portal.portal_catalog
    reference = sequence["reference"]
    assignment_function = sequence["assignment_function"]
    assignment_role = sequence["assignment_role"]
    credential_request = portal_catalog.getResultValue(
        portal_type="Credential Request", reference=reference)
    mail_message = portal_catalog.getResultValue(portal_type="Mail Message",
                                                 follow_up=credential_request)
    self.stepTic()
    self.logout()
    self.portal.ERP5Site_activeLogin(mail_message.getReference())
    self.login("ERP5TypeTestCase")
    self.stepTic()
    person = portal_catalog.getResultValue(reference=reference,
                                           portal_type="Person")
    assignment_list = person.objectValues(portal_type="Assignment")
    self.assertEquals(len(assignment_list), 1)
    assignment = assignment_list[0]
    self.assertEquals(assignment.getFunction(), assignment_function)
    self.assertEquals(assignment.getRole(), assignment_role)

  def getUserFolder(self):
    """Returns the acl_users. """
    return self.getPortal().acl_users

  def _assertUserExists(self, login, password):
    """Checks that a user with login and password exists and can log in to the
    system.
    """
    from Products.PluggableAuthService.interfaces.plugins import\
                                                      IAuthenticationPlugin
    uf = self.getUserFolder()
    self.assertNotEquals(uf.getUserById(login, None), None)
    for plugin_name, plugin in uf._getOb('plugins').listPlugins(
                                IAuthenticationPlugin):
      if plugin.authenticateCredentials(
                  {'login': login, 'password': password}) is not None:
        break
    else:
      self.fail("No plugin could authenticate '%s' with password '%s'" %
              (login, password))

  def _assertUserDoesNotExists(self, login, password):
    """Checks that a user with login and password does not exists and cannot
    log in to the system.
    """
    from Products.PluggableAuthService.interfaces.plugins import\
                                                        IAuthenticationPlugin
    uf = self.getUserFolder()
    for plugin_name, plugin in uf._getOb('plugins').listPlugins(
                              IAuthenticationPlugin):
      if plugin.authenticateCredentials(
                {'login': login, 'password': password}) is not None:
        self.fail(
           "Plugin %s should not have authenticated '%s' with password '%s'" %
           (plugin_name, login, password))

  def stepCreateSimpleSubscriptionRequest(self, sequence=None, sequence_list=None,
      **kw):
    '''
    Create a simple subscription request
    '''
    request = self.portal.REQUEST
    request['PARENTS'] = [self.app]
    form_url = self.portal.absolute_url_path() + '/ERP5Site_viewNewCredentialRequestDialog'

    # logout to be annonymous
    self.logout()
    # check annonymous can access subscription form
    self.assertTrue("Desired Login Name" in request.traverse(form_url)())
    # fill in and submit the subscription form
    credential_reference = 'homie'
    result = self.portal.ERP5Site_newCredentialRequest(\
        first_name='Homer',
        last_name='Simpson',
        reference=credential_reference,
        password='secret',
        default_email_text='homer.simpson@fox.com',
        role_list=['internal'],
        )
    portal_status_message = sequence.get("portal_status_message",
        "Thanks%20for%20your%20registration.%20You%20will%20be%20receive%20an%20email%20to%20activate%20your%20account.")
    self.assertTrue('portal_status_message=%s' % portal_status_message in result, result)

    credential_request_module = self.portal.getDefaultModule('Credential Request')
    result = credential_request_module.contentValues(\
        portal_type='Credential Request', first_name='Homer',
        last_name='Simpson', reference='homie')
    self.assertEquals(len(result), 1)
    sequence.edit(subscription_request=result[0],
        person_reference=credential_reference)

  def stepAcceptSubscriptionRequest(self, sequence=None, sequence_list=None,
      **kw):
    self.login()
    subscription_request = sequence.get('subscription_request')
    subscription_request.accept()
    self.logout()

  def stepSubmitSubscriptionRequest(self, sequence=None, sequence_list=None,
      **kw):
    self.login()
    subscription_request = sequence.get('subscription_request')
    subscription_request.submit()
    self.logout()

  def stepCheckAccountIsCreated(self, sequence=None, sequence_list=None, **kw):
    # check a person have been created
    person_module = self.portal.getDefaultModule('Person')
    person_result = person_module.contentValues(reference='homie')
    self.assertEquals(len(person_result), 1)
    person = person_result[0].getObject()
    self.assertEquals(person.getTitle(), 'Homer Simpson')
    self.assertEquals(person.getDefaultEmailText(), 'homer.simpson@fox.com')

    # check homie can log in the system
    self._assertUserExists('homie', 'secret')
    self.login('homie')
    from AccessControl import getSecurityManager
    self.assertEquals(str(getSecurityManager().getUser()), 'homie')

  def stepCreateCredentialUpdate(self, sequence=None, sequence_list=None, **kw):
    '''
    Create a credential update object an fill it with some modified
    informations
    '''
    self.login()
    # get the 'homie' person object
    person_module = self.portal.getDefaultModule('Person')
    result = person_module.searchFolder(reference='homie')
    self.assertEquals(len(result), 1)
    homie = result[0]

    # create a credential update
    credential_update_module = self.portal.getDefaultModule(\
        'Credential Update')
    credential_update = credential_update_module.newContent(\
        first_name='Homie',
        last_name='Simpsons', # add a 's' to the end of the last_name
        password='new_password',
        default_email_text='homie.simpsons@fox.com',
        destination_decision=homie.getRelativeUrl())

    credential_update.submit()
    self.assertEquals(credential_update.getValidationState(), 'submitted')
    sequence.edit(credential_update=credential_update)

  def stepAcceptCredentialUpdate(self, sequence=None, sequence_list=None,
      **kw):
    credential_update = sequence.get('credential_update')
    credential_update.accept()

  def stepCheckCredentialUpdate(self, sequence=None, sequence_list=None,
      **kw):
    self.login()
    # check the user with the updated password exists
    self._assertUserExists('homie', 'new_password')
    # check the user with the old password don't exists anymore
    self._assertUserDoesNotExists('homie', 'secret')

    # check that informations on the person object have been updated
    person_module = self.portal.getDefaultModule('Person')
    related_person_result = person_module.searchFolder(reference='homie')
    self.assertEquals(len(related_person_result), 1)
    related_person = related_person_result[0]
    self.assertEquals(related_person.getLastName(), 'Simpsons')
    self.assertEquals(related_person.getDefaultEmailText(),
    'homie.simpsons@fox.com')

  def stepCreateSubscriptionRequestWithSecurityQuestionCategory(self, sequence=None,
      sequence_list=None, **kw):
    request = self.portal.REQUEST
    request['PARENTS'] = [self.app]

    # fill in and submit the subscription form
    result = self._createCredentialRequest(\
        first_name='Homer',
        last_name='Simpson',
        reference='homie',
        password='secret',
        default_email_text='homer.simpson@fox.com',
        default_credential_question_question='credential/library_card_number',
        default_credential_question_answer='923R4293'
        )
    self.assertTrue('portal_status_message=Credential%20Request%20Created.'\
        in result)

    transaction.commit()
    self.tic()
    credential_request_module = self.portal.getDefaultModule('Credential Request')
    result = credential_request_module.contentValues(\
        portal_type='Credential Request', first_name='Homer',
        last_name='Simpson', reference='homie')
    self.assertEquals(len(result), 1)
    sequence.edit(subscription_request=result[0])

  def stepCheckSecurityQuestionCategoryAsBeenCopiedOnPersonObject(self, sequence=None,
      sequence_list=None, **kw):
    person_module = self.portal.getDefaultModule('Person')
    related_person_result = person_module.contentValues(reference='homie')
    self.assertEquals(len(related_person_result), 1)
    related_person = related_person_result[0]
    self.assertEquals(related_person.getDefaultCredentialQuestionQuestion(),
        'credential/library_card_number')
    self.assertEquals(related_person.getDefaultCredentialQuestionAnswer(),
        '923R4293')

  def stepCreateSubscriptionRequestWithSecurityQuestionFreeText(self, sequence=None,
      sequence_list=None, **kw):
    request = self.portal.REQUEST
    request['PARENTS'] = [self.app]

    # logout to be annonymous
    self.logout()
    # fill in and submit the subscription form
    result = self.portal.ERP5Site_newCredentialRequest(\
        first_name='Homer',
        last_name='Simpson',
        reference='homie',
        password='secret',
        default_email_text='homer.simpson@fox.com',
        default_credential_question_question_free_text='Which '\
            'car model do you have ?',
        default_credential_question_answer='Renault 4L'
        )
    self.assertTrue('portal_status_message=Credential%20Request%20Created.'\
        in result)

    transaction.commit()
    self.tic()
    credential_request_module = self.portal.getDefaultModule('Credential Request')
    result = credential_request_module.contentValues(\
        portal_type='Credential Request', first_name='Homer',
        last_name='Simpson', reference='homie')
    self.assertEquals(len(result), 1)
    sequence.edit(subscription_request=result[0])

  def stepCheckSecurityQuestionFreeTextAsBeenCopiedOnPersonObject(self, sequence=None,
      sequence_list=None, **kw):
    person_module = self.portal.getDefaultModule('Person')
    related_person_result = person_module.contentValues(reference='homie')
    self.assertEquals(len(related_person_result), 1)
    related_person = related_person_result[0]
    self.assertEquals(related_person.getDefaultCredentialQuestionQuestionFreeText(),
        'Which car model do you have ?')
    self.assertEquals(related_person.getDefaultCredentialQuestionAnswer(),
        'Renault 4L')

  def stepCreatePerson(self, sequence=None, sequence_list=None,
      **kw):
    """
      Create a simple person
    """
    portal = self.getPortalObject()
    # create a person with 'secret' as password
    self.login()
    person_module = portal.getDefaultModule('Person')
    person = person_module.newContent(title='Barney',
                             reference='barney',
                             password='secret',
                             default_email_text='barney@duff.com')
    # create an assignment
    assignment = person.newContent(portal_type='Assignment',
                      function='member')
    assignment.open()
    sequence.edit(person_reference=person.getReference())

  def stepCreateCredentialRecovery(self, sequence=None, sequence_list=None,
      **kw):
    '''
    Create a simple subscription request
    '''
    portal = self.getPortalObject()
    person_reference = sequence["person_reference"]
    person = portal.portal_catalog.getResultValue(portal_type="Person",
        reference=person_reference)
    sequence.edit(barney=person)
    # check barney can log in the system
    self._assertUserExists('barney', 'secret')
    self.login('barney')
    from AccessControl import getSecurityManager
    self.assertEquals(str(getSecurityManager().getUser()), 'barney')

    self.login()
    # create a credential recovery
    credential_recovery_module = portal.getDefaultModule('Credential Recovery')
    credential_recovery = credential_recovery_module.newContent(portal_type=\
        'Credential Recovery')

    # associate it with barney
    credential_recovery.setDestinationDecisionValue(person)
    sequence.edit(credential_recovery=credential_recovery)

  def stepRequestCredentialRecoveryWithERP5Site_newCredentialRecovery(self,
      sequence=None, sequence_list=None, **kw):
    person_reference = sequence["person_reference"]
    self.portal.ERP5Site_newCredentialRecovery(reference=person_reference)

  def stepLoginAsCurrentPersonReference(self, sequence=None,
      sequence_list=None, **kw):
    person_reference = sequence["person_reference"]
    self.login(person_reference)

  def stepCreateCredentialUpdateWithERP5Site_newCredentialUpdate(self,
      sequence=None, sequence_list=None, **kw):
    self.portal.ERP5Site_newPersonCredentialUpdate(first_name="tom",
        default_email_text="tom@host.com")

  def stepCreateCredentialRecoveryWithSensitiveAnswer(self, sequence=None,
      sequence_list=None, **kw):
    person_reference = sequence["person_reference"]
    result = self.portal.ERP5Site_newCredentialRecovery(
        reference=person_reference,
        default_credential_question_question='credential/library_card_number',
        default_credential_question_answer='ABCDeF',
        )
    message_str = "You%20didn%27t%20enter%20the%20correct%20answer."
    self.assertTrue(message_str not in result)
    self.stepTic()
    self.login()
    result_list = self.portal.portal_catalog(
        portal_type='Credential Recovery', reference=person_reference)
    self.assertEquals(1, len(result_list))
    credential_recovery = result_list[0]
    sequence.edit(credential_recovery=credential_recovery)

  def stepSelectCredentialUpdate(self, sequence=None, sequence_list=None,
      **kw):
    self.login()
    credential_update = self.portal.portal_catalog.getResultValue(
        portal_type="Credential Update")
    sequence["credential_update"] = credential_update

  def stepCheckCredentialRecoveryCreation(self, sequence=None, 
      sequence_list=None, **kw):
    person_reference = sequence["person_reference"]
    result_list = self.portal.portal_catalog(
        portal_type='Credential Recovery', reference=person_reference)
    self.assertEquals(1, len(result_list))
    credential_recovery = result_list[0]
    person = credential_recovery.getDestinationDecisionValue()
    self.assertEquals("Barney", person.getTitle())
    self.assertEquals("barney@duff.com", person.getEmailText())
    sequence["credential_recovery"] = credential_recovery

  def stepSubmitCredentialRecovery(self, sequence=None, sequence_list=None,
      **kw):
    credential_recovery = sequence.get('credential_recovery')
    credential_recovery.submit()

  def stepAcceptCredentialRecovery(self, sequence=None, sequence_list=None,
      **kw):
    credential_recovery = sequence.get('credential_recovery')
    credential_recovery.accept()

  def stepCheckEmailIsSent(self, sequence=None, sequence_list=None, **kw):
    '''
      Check an email containing the password reset link as been sent
    '''
    barney = sequence.get('barney')
    if not barney:
      reference = sequence.get('person_reference')
      barney = self.portal.portal_catalog.getResultValue(portal_type="Person",
          reference=reference)

    # after accept, an email is send containing the reset link
    last_message = self.portal.MailHost._last_message
    rawstr = r"""PasswordTool_viewResetPassword"""
    decoded_message = self.decode_email(last_message[2])
    body_message = decoded_message['body']
    match_obj = re.search(rawstr, body_message)

    # check the reset password link is in the mail
    self.assertNotEquals(match_obj, None)

    # check the mail is sent to the requester :
    send_to = decoded_message['headers']['to']
    self.assertEqual(barney.getDefaultEmailText(), send_to)

  def stepCheckPasswordChange(self, sequence=None, sequence_list=None, **kw):
    '''
      check it's possible to change the user password using the link in the
      email
    '''
    # get the url
    last_message = self.portal.MailHost._last_message
    rawstr = r"""PasswordTool_viewResetPassword"""
    decoded_message = self.decode_email(last_message[2])
    body_message = decoded_message['body']
    match_obj = re.search(rawstr, body_message)
    # check the reset password link is in the mail
    self.assertNotEquals(match_obj, None)
    url = None
    for line in body_message.splitlines():
      match_obj = re.search(rawstr, line)
      if match_obj is not None:
        url = line[line.find('http:'):]
    url = url.strip()
    self.assertNotEquals(url, None)
    response = self.publish(url)
    parameters = cgi.parse_qs(urlparse(url)[4])
    self.assertTrue('reset_key' in parameters)
    key = parameters['reset_key'][0]
    # before changing, check that the user exists with 'secret' password
    self._assertUserExists('barney', 'secret')
    self.portal.portal_password.changeUserPassword(user_login="barney",
                                                   password="new_password",
                                                   password_confirmation="new_password",
                                                   password_key=key)
    transaction.commit()
    self.tic()
    # reset the cache
    self.portal.portal_caches.clearAllCache()
    # check we cannot login anymore with the previous password 'secret'
    self._assertUserDoesNotExists('barney', 'secret')

    # check we can now login with the new password 'new_password'
    self._assertUserExists('barney', 'new_password')

  def _createCredentialRequest(self, first_name="Barney",
                               last_name="Simpson",
                               reference="barney",
                               password="secret",
                               default_email_text="barney@duff.com",
                               **kw):
    self.logout()
    result = self.portal.ERP5Site_newCredentialRequest(first_name=first_name,
        last_name=last_name,
        reference=reference,
        password=password,
        career_subordination_title="",
        default_email_text=default_email_text,
        default_telephone_text="223344",
        default_address_street_address="Test Street",
        default_address_city="Campos",
        default_address_zip_code="28024030",
        **kw)
    self.login("ERP5TypeTestCase")
    self.stepTic()
    return result

  def stepCreateCredentialRequestSample(self, sequence=None,
      sequence_list=None, **kw):
    credential_reference = "credential_reference"
    self._createCredentialRequest(reference=credential_reference)
    sequence.edit(credential_reference=credential_reference)

  def stepCheckIfMailMessageWasPosted(self, sequence=None,
      sequence_list=None, **kw):
    credential_reference_str = sequence["credential_reference"]
    portal_catalog = self.portal.portal_catalog
    credential_reference = portal_catalog.getResultValue(
        portal_type="Credential Request", reference=credential_reference_str)
    mail_message = portal_catalog.getResultValue(portal_type="Mail Message",
                                                 follow_up=credential_reference)
    self.assertEquals(mail_message.getSimulationState(), "started")
    self.assertTrue("key=%s" % mail_message.getReference() in mail_message.getTextContent())

  def stepSetPreferredCredentialAlarmAutomaticCallAsFalse(self, sequence):
    sequence.edit(automatic_call=False)

  def stepSetAssigneeRoleToCurrentPersonInCredentialUpdateModule(self,
      sequence=None, sequence_list=None, **kw):
    person_reference = sequence["person_reference"]
    self.portal.credential_update_module.manage_setLocalRoles(person_reference,
        ['Assignor',])

  def stepSetAssigneeRoleToCurrentPersonInCredentialRecoveryModule(self,
      sequence=None, sequence_list=None, **kw):
    person_reference = sequence["person_reference"]
    self.portal.credential_recovery_module.manage_setLocalRoles(person_reference,
        ['Assignor',])

  def stepLogin(self, sequence):
    self.login()

  def stepSetAuditorRoleToCurrentPerson(self, sequence=None,
      sequence_list=None, **kw):
    person_reference = sequence["person_reference"]
    self.login()
    person = self.portal.portal_catalog.getResultValue(portal_type="Person",
        reference=person_reference)
    person.manage_setLocalRoles(person_reference, ["Auditor"])
    self.logout()

  def stepCheckPersonAfterUpdatePerson(self, sequence=None,
      sequence_list=None, **kw):
    person = self.portal.portal_catalog.getResultValue(
      reference=sequence["person_reference"], portal_type="Person")
    self.assertEquals("tom", person.getFirstName())
    self.assertEquals("Simpson", person.getLastName())
    self.assertEquals("tom@host.com", person.getDefaultEmailText())

  def stepCheckPersonWhenCredentialUpdateFail(self, sequence=None,
      sequence_list=None, **kw):
    person = self.portal.portal_catalog.getResultValue(
      reference=sequence["person_reference"], portal_type="Person")
    self.assertEquals("Barney", person.getFirstName())

  def test_01_simpleSubscriptionRequest(self):
    '''
    Check that is possible to subscribe to erp5
    '''
    sequence_list = SequenceList()
    sequence_string = 'CreateSimpleSubscriptionRequest Tic '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_02_acceptSubscriptionRequest(self):
    '''
    Check that after approval, the account is created and the user is able to
    log in the system.
    '''
    sequence_list = SequenceList()
    sequence_string = 'CreateSimpleSubscriptionRequest Tic '\
                      'AcceptSubscriptionRequest Tic '\
                      'CheckAccountIsCreated Tic '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_03_simpleCredentialUpdate(self):
    '''
    Check it's possible to update credential informations using credential
    update
    '''
    sequence_list = SequenceList()
    sequence_string = 'CreateSimpleSubscriptionRequest '\
                      'AcceptSubscriptionRequest Tic '\
                      'CreateCredentialUpdate '\
                      'AcceptCredentialUpdate Tic '\
                      'CheckCredentialUpdate '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_04_automaticCredentialRequestApproval(self):
    '''
    if the property preferred_credential_request_automatic_approval is True on
    System Preference object. it means that the Credential Request object
    should be accepted automatically and account created without any human
    intervention.
    Check that the user is create without human intervention
    '''
    sequence_list = SequenceList()
    sequence_string = 'SetCredentialRequestAutomaticApprovalPreferences '\
                      'CreateSimpleSubscriptionRequest Tic '\
                      'CheckAccountIsCreated '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_05_automaticCredentialUpdateApproval(self):
    '''
    if the property preferred_credential_request_automatic_approval is True on
    System Preference object. it means that the Credential Update object
    should be accepted automatically and account created without any human
    intervention.
    Check that the user is create without human intervention
    '''
    sequence_list = SequenceList()
    sequence_string = 'SetPersonCredentialUpdateAutomaticApprovalPreferences '\
                      'CreateSimpleSubscriptionRequest '\
                      'AcceptSubscriptionRequest Tic '\
                      'CheckAccountIsCreated '\
                      'CreateCredentialUpdate Tic '\
                      'CheckCredentialUpdate '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_06_checkSecurityQuestionCategoryDefinition(self):
    '''
    Check that its possible to define a security question selecting a category
    or by entering free text.
    '''
    sequence_list = SequenceList()
    sequence_string = 'CreateSubscriptionRequestWithSecurityQuestionCategory '\
                      'AcceptSubscriptionRequest Tic '\
                      'CheckSecurityQuestionCategoryAsBeenCopiedOnPersonObject '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_07_checkSecurityQuestionFreeTextDefinition(self):
    '''
    Check that its possible to define a security question selecting a category
    or by entering free text.
    '''
    sequence_list = SequenceList()
    sequence_string = 'CreateSubscriptionRequestWithSecurityQuestionFreeText '\
                      'AcceptSubscriptionRequest Tic '\
                      'CheckSecurityQuestionFreeTextAsBeenCopiedOnPersonObject '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_08_passwordRecovery(self):
    '''
    check that a user that forget his password is able to set a new one and
    log in the system with this new password
    '''
    sequence_list = SequenceList()
    sequence_string = 'CreatePerson Tic '\
                      'CreateCredentialRecovery Tic '\
                      'SubmitCredentialRecovery Tic '\
                      'AcceptCredentialRecovery Tic '\
                      'CheckEmailIsSent Tic '\
                      'CheckPasswordChange Tic '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def testMailMessagePosted(self):
    """ Test if the Mail Message was posted correctly """
    sequence_list = SequenceList()
    sequence_string = 'SetPreferredCredentialAlarmAutomaticCallAsFalse '\
                      'SetCredentialRequestAutomaticApprovalPreferences '\
                      'CreateCredentialRequestSample '\
                      'CheckIfMailMessageWasPosted '\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def testMailFromMailMessageEvent(self):
    """
      Check that the email is created correctly after create on Credentail
      Request with user's information
    """
    sequence = dict(automatic_call=False)
    self.stepSetCredentialRequestAutomaticApprovalPreferences(sequence)
    self._createCredentialRequest(first_name="Vifib", 
                                 last_name="Test",
                                 reference="vifibtest")
    portal_catalog = self.portal.portal_catalog
    credential_request = portal_catalog.getResultValue(
        portal_type="Credential Request", reference="vifibtest", 
        first_name="Vifib", last_name="Test")
    mail_message = portal_catalog.getResultValue(
        portal_type="Mail Message", follow_up=credential_request)
    last_message = self.portal.MailHost._last_message
    self.assertNotEquals((), last_message)
    mfrom, mto, message_text = last_message
    self.assertEquals(mfrom, 'Portal Administrator <postmaster@localhost>')
    self.assertEquals(['Vifib Test <barney@duff.com>'], mto)
    self.assertNotEquals(re.search("Subject\:.*Welcome", message_text), None)
    self.assertNotEquals(re.search("Hello\ Vifib\ Test\,", message_text), None)
    self.assertNotEquals(re.search("key\=..%s" % mail_message.getReference(),
      message_text), None)

  def testAssignmentCreationUsingSystemPreferenceProperty(self):
    """
      Check that the category list are used correctly to create a new
      assignment
    """
    sequence = dict(automatic_call=False)
    self.stepSetCredentialRequestAutomaticApprovalPreferences(sequence)
    self.stepSetCredentialAssignmentPropertyList()
    self._createCredentialRequest()
    sequence = dict(reference="barney",
                   assignment_function="member",
                   assignment_role="internal")
    self.stepCheckAssignmentAfterActiveLogin(sequence)
    category_list = ["role/client", "function/agent"]
    self.stepSetCredentialAssignmentPropertyList(
        dict(category_list=category_list))
    self._createCredentialRequest(reference="credential_user")
    sequence = dict(reference="credential_user",
                   assignment_function="agent",
                   assignment_role="client")
    self.stepCheckAssignmentAfterActiveLogin(sequence)

  def testERP5Site_activeLogin(self):
    """
      Test if the script WebSection_activeLogin will create one user
    correctly
    """
    sequence = dict(automatic_call=False)
    self.stepSetCredentialRequestAutomaticApprovalPreferences(sequence)
    self.stepSetCredentialAssignmentPropertyList()
    self.stepTic()
    self._createCredentialRequest()
    portal_catalog = self.portal.portal_catalog
    credential_request = portal_catalog.getResultValue(
        portal_type="Credential Request", reference="barney")
    mail_message = portal_catalog.getResultValue(portal_type="Mail Message",
                                                 follow_up=credential_request)
    self.logout()
    self.portal.ERP5Site_activeLogin(mail_message.getReference())
    self.login("ERP5TypeTestCase")
    self.stepTic()
    person = portal_catalog.getResultValue(reference="barney",
        portal_type="Person")
    assignment_list = person.objectValues(portal_type="Assignment")
    self.assertNotEquals(assignment_list, [])
    self.assertEquals(len(assignment_list), 1)
    assignment = assignment_list[0]
    self.assertEquals(assignment.getValidationState(), "open")
    self.assertEquals(person.getValidationState(), "validated")

  def testERP5Site_newCredentialRequest(self):
    """
      Check that the script ERP5Site_newCredentialRequest will create one
      Credential Request correctly
    """
    sequence = dict(automatic_call=False)
    self.stepSetCredentialRequestAutomaticApprovalPreferences(sequence)
    self.stepSetCredentialAssignmentPropertyList()
    self._createCredentialRequest()
    portal_catalog = self.portal.portal_catalog
    credential_request = portal_catalog.getResultValue(
        portal_type="Credential Request", reference="barney")
    self.assertEquals(credential_request.getFirstName(), "Barney")
    self.assertEquals(credential_request.getDefaultEmailText(),
        "barney@duff.com")
    self.assertEquals(credential_request.getRole(), "internal")
    self.assertEquals(credential_request.getFunction(), "member")

  def test_double_ERP5Site_newCredentialRequest(self):
    """Check that ERP5Site_newCredentialRequest will not create conflicting
       credentials."""
    sequence = dict(automatic_call=True)
    self.stepSetCredentialRequestAutomaticApprovalPreferences(sequence)
    self.stepSetCredentialAssignmentPropertyList()
    response = self._createCredentialRequest()
    self.assertTrue('Credential%20Request%20Created.' in response)
    portal_catalog = self.portal.portal_catalog
    credential_request = portal_catalog.getResultValue(
        portal_type="Credential Request", reference="barney")
    self.assertEquals(credential_request.getFirstName(), "Barney")
    self.assertEquals(credential_request.getDefaultEmailText(),
        "barney@duff.com")
    self.assertEquals(credential_request.getRole(), "internal")
    self.assertEquals(credential_request.getFunction(), "member")

    self.portal.portal_alarms.accept_submitted_credentials.activeSense()
    transaction.commit()
    self.tic()
    self.assertEqual('accepted', credential_request.getValidationState())

    response = self._createCredentialRequest()
    self.assertTrue('Selected%20login%20is%20already%20in%20use%2C%20pl'
      'ease%20choose%20different%20one' in  response)

    self.portal.portal_alarms.accept_submitted_credentials.activeSense()
    transaction.commit()
    self.tic()

  def test_double_ERP5Site_newCredentialRequest_indexation(self):
    """Check that ERP5Site_newCredentialRequest will react correctly in case
       if indexation is still ongoing."""
    sequence = dict(automatic_call=True)
    self.stepSetCredentialRequestAutomaticApprovalPreferences(sequence)
    self.stepSetCredentialAssignmentPropertyList()
    reference = self.id()
    self.logout()
    response = self.portal.ERP5Site_newCredentialRequest(reference=reference,
        default_email_text='some@one.com',)
    self.login()
    self.assertTrue('Credential%20Request%20Created.' in response)
    transaction.commit()
    self.logout()
    response = self.portal.ERP5Site_newCredentialRequest(reference=reference,
        default_email_text='some@one.com',)
    self.login()
    # Now is time to assert that even if no reindexation was done yet, another
    # request will already refuse to create new credential request.
    self.assertTrue('Selected%20login%20is%20already%20in%20use%2C%20pl'
      'ease%20choose%20different%20one' in response)
    transaction.commit()
    self.tic()
    # just to be sure that last response not resulted with creation of object
    self.assertEqual(1, self.portal.portal_catalog.countResults(
      portal_type='Credential Request', reference=reference)[0][0])

  def testERP5Site_newCredentialRecoveryWithNoSecurityQuestion(self):
    """
      Check that password recovery works when security question and answer are
      None
    """
    sequence_list = SequenceList()
    sequence_string = "CreatePerson Tic " \
           "RequestCredentialRecoveryWithERP5Site_newCredentialRecovery Tic " \
           "CheckCredentialRecoveryCreation " \
           "AcceptCredentialRecovery Tic "\
           "CheckEmailIsSent Tic "\
           "CheckPasswordChange "\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def testERP5Site_newCredentialUpdateWithNoSecurityQuestion(self):
    """
      Check that the script ERP5Site_newCredentialUpdate creates correctly one
      Credential Update object is create correctly and the user is updated with
      new properties
    """
    sequence_list = SequenceList()
    sequence_string = "CreateSimpleSubscriptionRequest Tic " \
           "AcceptSubscriptionRequest Tic " \
           "SetAuditorRoleToCurrentPerson " \
           "SetAssigneeRoleToCurrentPersonInCredentialUpdateModule Tic " \
           "LoginAsCurrentPersonReference " \
           "CreateCredentialUpdateWithERP5Site_newCredentialUpdate Tic " \
           "SelectCredentialUpdate " \
           "AcceptCredentialUpdate Tic "\
           "CheckPersonAfterUpdatePerson "\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)

  def test_no_reset_assignment_ERP5Site_newCredentialUpdate(self):
    """Checks that assignments are left intact after credential update"""
    reference = self.id()
    person = self.portal.person_module.newContent(portal_type='Person',
      reference=reference,
      password='secret',
      role='internal')
    assignment = person.newContent(portal_type='Assignment', function='manager')
    assignment.open()
    transaction.commit()
    credential_update = self.portal.credential_update_module.newContent(
        portal_type='Credential Update',
        first_name='Some Name',
        destination_decision_value=person
      )
    credential_update.submit()
    credential_update.accept()
    self.tic()

    self.assertEqual('Some Name', person.getFirstName())
    self.assertEqual('manager', assignment.getFunction())

  def stepCreatePersonWithQuestionUsingCamelCase(self, sequence):
    person_module = self.portal.getDefaultModule('Person')
    person = person_module.newContent(title='Barney',
                             reference='barney',
                             password='secret',
                             default_email_text='barney@duff.com')
    # create an assignment
    assignment = person.newContent(portal_type='Assignment',
                      function='member')
    assignment.open()
    sequence.edit(person_reference=person.getReference())

  def test_checkCredentialQuestionIsNotCaseSensitive(self):
    '''
      Check that if the user enter an answer with a different case, this will still
    enought to reset his passord
    '''
    sequence_list = SequenceList()
    sequence_string = "CreatePersonWithQuestionUsingCamelCase Tic " \
        "LoginAsCurrentPersonReference " \
        "CreateCredentialRecoveryWithSensitiveAnswer Tic " \
        "AcceptCredentialRecovery Tic " \
        "CheckEmailIsSent Tic "\
        "CheckPasswordChange Tic "\

    sequence_list.addSequenceString(sequence_string)
    sequence_list.play(self)


def test_suite():
  suite = unittest.TestSuite()
  suite.addTest(unittest.makeSuite(TestERP5Credential))
  return suite