testCMFActivity.py 145 KB
Newer Older
Sebastien Robin's avatar
Sebastien Robin committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
##############################################################################
#
# Copyright (c) 2004 Nexedi SARL and Contributors. All Rights Reserved.
#          Sebastien Robin <seb@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.
#
##############################################################################


Jérome Perrin's avatar
Jérome Perrin committed
30
import unittest
Sebastien Robin's avatar
Sebastien Robin committed
31

32
from Products.ERP5Type.tests.utils import LogInterceptor
33
from Products.ERP5Type.tests.backportUnittest import skip
Sebastien Robin's avatar
Sebastien Robin committed
34 35
from Testing import ZopeTestCase
from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
36
from Products.ERP5Type.tests.utils import DummyMailHost
37
from Products.ERP5Type.TransactionalVariable import getTransactionalVariable
38 39 40
from Products.CMFActivity.ActiveObject import INVOKE_ERROR_STATE,\
                                              VALIDATE_ERROR_STATE
from Products.CMFActivity.Activity.Queue import VALIDATION_ERROR_DELAY
41
from Products.CMFActivity.Activity.SQLDict import SQLDict
42
import Products.CMFActivity.ActivityTool
43
from Products.CMFActivity.Errors import ActivityPendingError, ActivityFlushError
44
from erp5.portal_type import Organisation
45
from AccessControl.SecurityManagement import newSecurityManager
Sebastien Robin's avatar
Sebastien Robin committed
46
from zLOG import LOG
47
from ZODB.POSException import ConflictError
48
from DateTime import DateTime
49 50
import cPickle as pickle
from Products.CMFActivity.ActivityTool import Message
51
import gc
52
import random
53
import threading
54
import sys
55
import weakref
56
import transaction
57

Julien Muchembled's avatar
Julien Muchembled committed
58 59 60 61 62 63 64 65 66 67 68 69 70 71
class CommitFailed(Exception):
  pass

def registerFailingTransactionManager(*args, **kw):
  from Shared.DC.ZRDB.TM import TM
  class dummy_tm(TM):
    def tpc_vote(self, *ignored):
      raise CommitFailed
    def _finish(self):
      pass
    def _abort(self):
      pass
  dummy_tm()._register()

72
class TestCMFActivity(ERP5TypeTestCase, LogInterceptor):
Sebastien Robin's avatar
Sebastien Robin committed
73 74 75 76 77 78

  run_all_test = 1
  # Different variables used for this test
  company_id = 'Nexedi'
  title1 = 'title1'
  title2 = 'title2'
79
  company_id2 = 'Coramy'
80
  company_id3 = 'toto'
Sebastien Robin's avatar
Sebastien Robin committed
81

Sebastien Robin's avatar
Sebastien Robin committed
82 83 84
  def getTitle(self):
    return "CMFActivity"

Sebastien Robin's avatar
Sebastien Robin committed
85 86 87 88
  def getBusinessTemplateList(self):
    """
      Return the list of business templates.
    """
Sebastien Robin's avatar
Sebastien Robin committed
89
    return ('erp5_base',)
Sebastien Robin's avatar
Sebastien Robin committed
90 91 92 93 94 95 96 97 98 99 100 101 102

  def getCategoriesTool(self):
    return getattr(self.getPortal(), 'portal_categories', None)

  def getRuleTool(self):
    return getattr(self.getPortal(), 'portal_Rules', None)

  def getPersonModule(self):
    return getattr(self.getPortal(), 'person', None)

  def getOrganisationModule(self):
    return getattr(self.getPortal(), 'organisation', None)

103
  def afterSetUp(self):
104
    super(TestCMFActivity, self).afterSetUp()
105 106 107 108
    from Products.CMFActivity.ActivityRuntimeEnvironment import BaseMessage
    # Set 'max_retry' to a known value so that we can test the feature
    BaseMessage.max_retry = property(lambda self:
      self.activity_kw.get('max_retry', 5))
Sebastien Robin's avatar
Sebastien Robin committed
109
    self.login()
110 111 112 113 114 115 116
    portal = self.portal
    # trap outgoing e-mails
    self.oldMailHost = getattr(self.portal, 'MailHost', None)
    if self.oldMailHost is not None:
      self.portal.manage_delObjects(['MailHost'])
      self.portal._setObject('MailHost', DummyMailHost('MailHost'))
    
117 118 119 120 121
    # remove all message in the message_table because
    # the previous test might have failed
    message_list = portal.portal_activities.getMessageList()
    for message in message_list:
      portal.portal_activities.manageCancel(message.object_path,message.method_id)
122

Sebastien Robin's avatar
Sebastien Robin committed
123 124 125 126 127 128 129 130
    # Then add new components
    if not(hasattr(portal,'organisation')):
      portal.portal_types.constructContent(type_name='Organisation Module',
                                         container=portal,
                                         id='organisation')
    organisation_module = self.getOrganisationModule()
    if not(organisation_module.hasContent(self.company_id)):
      o1 = organisation_module.newContent(id=self.company_id)
131
    self.stepTic()
Sebastien Robin's avatar
Sebastien Robin committed
132 133 134 135

  def login(self, quiet=0, run=run_all_test):
    uf = self.getPortal().acl_users
    uf._doAddUser('seb', '', ['Manager'], [])
136
    uf._doAddUser('ERP5TypeTestCase', '', ['Manager'], [])
Sebastien Robin's avatar
Sebastien Robin committed
137 138 139
    user = uf.getUserById('seb').__of__(uf)
    newSecurityManager(None, user)

140
  def InvokeAndCancelActivity(self, activity):
141 142 143
    """
    Simple test where we invoke and cancel an activity
    """
Sebastien Robin's avatar
Sebastien Robin committed
144 145
    portal = self.getPortal()
    organisation =  portal.organisation._getOb(self.company_id)
146
    organisation._setTitle(self.title1)
Sebastien Robin's avatar
Sebastien Robin committed
147
    self.assertEquals(self.title1,organisation.getTitle())
148
    organisation.activate(activity=activity)._setTitle(self.title2)
Sebastien Robin's avatar
Sebastien Robin committed
149
    # Needed so that the message are commited into the queue
150
    self.commit()
151 152
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),1)
153
    portal.portal_activities.manageCancel(organisation.getPhysicalPath(),'_setTitle')
154
    # Needed so that the message are removed from the queue
155
    self.commit()
Sebastien Robin's avatar
Sebastien Robin committed
156
    self.assertEquals(self.title1,organisation.getTitle())
157 158
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
159
    organisation.activate(activity=activity)._setTitle(self.title2)
160
    # Needed so that the message are commited into the queue
161
    self.commit()
162 163
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),1)
164
    portal.portal_activities.manageInvoke(organisation.getPhysicalPath(),'_setTitle')
165
    # Needed so that the message are removed from the queue
166
    self.commit()
Sebastien Robin's avatar
Sebastien Robin committed
167 168 169 170
    self.assertEquals(self.title2,organisation.getTitle())
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)

Yoshinori Okuji's avatar
Yoshinori Okuji committed
171
  def DeferredSetTitleActivity(self, activity):
172 173 174 175
    """
    We check that the title is changed only after that
    the activity was called
    """
Sebastien Robin's avatar
Sebastien Robin committed
176
    portal = self.getPortal()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
177
    organisation = portal.organisation._getOb(self.company_id)
178
    organisation._setTitle(self.title1)
Sebastien Robin's avatar
Sebastien Robin committed
179
    self.assertEquals(self.title1,organisation.getTitle())
180
    organisation.activate(activity=activity)._setTitle(self.title2)
Sebastien Robin's avatar
Sebastien Robin committed
181
    # Needed so that the message are commited into the queue
182
    self.commit()
Sebastien Robin's avatar
Sebastien Robin committed
183 184 185 186 187 188 189
    self.assertEquals(self.title1,organisation.getTitle())
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
    self.assertEquals(self.title2,organisation.getTitle())
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)

190
  def CallOnceWithActivity(self, activity):
191 192 193 194
    """
    With this test we can check if methods are called
    only once (sometimes it was twice !!!)
    """
Sebastien Robin's avatar
Sebastien Robin committed
195
    portal = self.getPortal()
196 197 198 199 200 201 202
    def setFoobar(self):
      if hasattr(self,'foobar'):
        self.foobar = self.foobar + 1
      else:
        self.foobar = 1
    def getFoobar(self):
      return (getattr(self,'foobar',0))
Sebastien Robin's avatar
Sebastien Robin committed
203
    organisation =  portal.organisation._getOb(self.company_id)
204 205 206
    Organisation.setFoobar = setFoobar
    Organisation.getFoobar = getFoobar
    organisation.foobar = 0
207
    organisation._setTitle(self.title1)
208 209
    self.assertEquals(0,organisation.getFoobar())
    organisation.activate(activity=activity).setFoobar()
Sebastien Robin's avatar
Sebastien Robin committed
210
    # Needed so that the message are commited into the queue
211
    self.commit()
212 213
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),1)
Sebastien Robin's avatar
Sebastien Robin committed
214 215
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
216
    self.assertEquals(1,organisation.getFoobar())
Sebastien Robin's avatar
Sebastien Robin committed
217 218
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
219 220
    organisation.activate(activity=activity).setFoobar()
    # Needed so that the message are commited into the queue
221
    self.commit()
222 223 224 225
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),1)
    portal.portal_activities.manageInvoke(organisation.getPhysicalPath(),'setFoobar')
    # Needed so that the message are commited into the queue
226
    self.commit()
227 228 229 230
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
    self.assertEquals(2,organisation.getFoobar())

231
  def TryFlushActivity(self, activity):
232 233 234
    """
    Check the method flush
    """
235 236
    portal = self.getPortal()
    organisation =  portal.organisation._getOb(self.company_id)
237 238
    organisation._setTitle(self.title1)
    organisation.activate(activity=activity)._setTitle(self.title2)
239
    organisation.flushActivity(invoke=1)
240
    self.assertEquals(organisation.getTitle(),self.title2)
241
    self.commit()
242 243 244
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
    self.assertEquals(organisation.getTitle(),self.title2)
245
    # Try again with different commit order
246 247
    organisation._setTitle(self.title1)
    organisation.activate(activity=activity)._setTitle(self.title2)
248
    self.commit()
249 250 251
    organisation.flushActivity(invoke=1)
    self.assertEquals(len(message_list),0)
    self.assertEquals(organisation.getTitle(),self.title2)
252
    self.commit()
253

254
  def TryActivateInsideFlush(self, activity):
255 256 257
    """
    Create a new activity inside a flush action
    """
258 259
    portal = self.getPortal()
    def DeferredSetTitle(self,value):
260
      self.activate(activity=activity)._setTitle(value)
261 262
    Organisation.DeferredSetTitle = DeferredSetTitle
    organisation =  portal.organisation._getOb(self.company_id)
263
    organisation._setTitle(self.title1)
264 265
    organisation.activate(activity=activity).DeferredSetTitle(self.title2)
    organisation.flushActivity(invoke=1)
266
    self.commit()
267 268
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
269
    self.commit()
270 271 272 273 274
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
    self.assertEquals(organisation.getTitle(),self.title2)

  def TryTwoMethods(self, activity):
275 276 277
    """
    Try several activities
    """
278 279
    portal = self.getPortal()
    def DeferredSetDescription(self,value):
280
      self._setDescription(value)
281
    def DeferredSetTitle(self,value):
282
      self._setTitle(value)
283 284 285
    Organisation.DeferredSetTitle = DeferredSetTitle
    Organisation.DeferredSetDescription = DeferredSetDescription
    organisation =  portal.organisation._getOb(self.company_id)
286
    organisation._setTitle(None)
287 288 289
    organisation.setDescription(None)
    organisation.activate(activity=activity).DeferredSetTitle(self.title1)
    organisation.activate(activity=activity).DeferredSetDescription(self.title1)
290
    self.commit()
291 292
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
293
    self.commit()
294 295 296 297 298 299
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
    self.assertEquals(organisation.getTitle(),self.title1)
    self.assertEquals(organisation.getDescription(),self.title1)

  def TryTwoMethodsAndFlushThem(self, activity):
300 301 302
    """
    make sure flush works with several activities
    """
303 304
    portal = self.getPortal()
    def DeferredSetTitle(self,value):
305
      self.activate(activity=activity)._setTitle(value)
306
    def DeferredSetDescription(self,value):
307
      self.activate(activity=activity)._setDescription(value)
308 309 310
    Organisation.DeferredSetTitle = DeferredSetTitle
    Organisation.DeferredSetDescription = DeferredSetDescription
    organisation =  portal.organisation._getOb(self.company_id)
311
    organisation._setTitle(None)
312 313 314 315
    organisation.setDescription(None)
    organisation.activate(activity=activity).DeferredSetTitle(self.title1)
    organisation.activate(activity=activity).DeferredSetDescription(self.title1)
    organisation.flushActivity(invoke=1)
316
    self.commit()
317 318
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
319
    self.commit()
320 321 322 323 324
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
    self.assertEquals(organisation.getTitle(),self.title1)
    self.assertEquals(organisation.getDescription(),self.title1)

325
  def TryActivateFlushActivateTic(self, activity,second=None,commit_sub=0):
326 327 328
    """
    try to commit sub transactions
    """
329 330 331
    portal = self.getPortal()
    def DeferredSetTitle(self,value,commit_sub=0):
      if commit_sub:
332
        transaction.savepoint(optimistic=True)
333
      self.activate(activity=second or activity,priority=4)._setTitle(value)
334 335
    def DeferredSetDescription(self,value,commit_sub=0):
      if commit_sub:
336
        transaction.savepoint(optimistic=True)
337
      self.activate(activity=second or activity,priority=4)._setDescription(value)
338 339 340
    Organisation.DeferredSetTitle = DeferredSetTitle
    Organisation.DeferredSetDescription = DeferredSetDescription
    organisation =  portal.organisation._getOb(self.company_id)
341
    organisation._setTitle(None)
342 343 344 345
    organisation.setDescription(None)
    organisation.activate(activity=activity).DeferredSetTitle(self.title1,commit_sub=commit_sub)
    organisation.flushActivity(invoke=1)
    organisation.activate(activity=activity).DeferredSetDescription(self.title1,commit_sub=commit_sub)
346
    self.commit()
347 348
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
349
    self.commit()
350 351
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
352
    self.commit()
353 354 355 356 357
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)
    self.assertEquals(organisation.getTitle(),self.title1)
    self.assertEquals(organisation.getDescription(),self.title1)

358
  def TryMessageWithErrorOnActivity(self, activity):
359 360 361
    """
    Make sure that message with errors are not deleted
    """
362 363 364 365 366 367 368
    portal = self.getPortal()
    def crashThisActivity(self):
      self.IWillCrach()
    organisation =  portal.organisation._getOb(self.company_id)
    Organisation.crashThisActivity = crashThisActivity
    organisation.activate(activity=activity).crashThisActivity()
    # Needed so that the message are commited into the queue
369
    self.commit()
370
    message_list = portal.portal_activities.getMessageList()
371
    LOG('Before MessageWithErrorOnActivityFails, message_list',0,[x.__dict__ for x in message_list])
372 373 374
    self.assertEquals(len(message_list),1)
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
375
    # XXX HERE WE SHOULD USE TIME SHIFT IN ORDER TO SIMULATE MULTIPLE TICS
376 377 378 379 380
    # Test if there is still the message after it crashed
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),1)
    portal.portal_activities.manageCancel(organisation.getPhysicalPath(),'crashThisActivity')
    # Needed so that the message are commited into the queue
381
    self.commit()
382 383 384
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)

Yoshinori Okuji's avatar
Yoshinori Okuji committed
385
  def DeferredSetTitleWithRenamedObject(self, activity):
386
    """
387 388
    make sure that it is impossible to rename an object
    if some activities are still waiting for this object
389 390 391
    """
    portal = self.getPortal()
    organisation =  portal.organisation._getOb(self.company_id)
392
    organisation._setTitle(self.title1)
393
    self.assertEquals(self.title1,organisation.getTitle())
394
    organisation.activate(activity=activity)._setTitle(self.title2)
395
    # Needed so that the message are commited into the queue
396
    self.commit()
397
    self.assertEquals(self.title1,organisation.getTitle())
398
    self.assertRaises(ActivityPendingError,organisation.edit,id=self.company_id2)
399 400 401 402 403 404 405 406 407
    portal.portal_activities.distribute()
    portal.portal_activities.tic()

  def TryActiveProcess(self, activity):
    """
    Try to store the result inside an active process
    """
    portal = self.getPortal()
    organisation =  portal.organisation._getOb(self.company_id)
408
    organisation._setTitle(self.title1)
409 410 411 412
    active_process = portal.portal_activities.newActiveProcess()
    self.assertEquals(self.title1,organisation.getTitle())
    organisation.activate(activity=activity,active_process=active_process).getTitle()
    # Needed so that the message are commited into the queue
413
    self.commit()
414 415 416 417
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
418 419
    self.assertEquals(self.title1,organisation.getTitle())
    result = active_process.getResultList()[0]
420 421
    self.assertEquals(result.method_id , 'getTitle')
    self.assertEquals(result.result , self.title1)
422 423 424
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),0)

425 426
  def TryMethodAfterMethod(self, activity):
    """
427
      Ensure the order of an execution by a method id
428 429
    """
    portal = self.getPortal()
430 431 432 433
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = portal.organisation._getOb(self.company_id)
434

435 436 437
    o.setTitle('a')
    self.assertEquals(o.getTitle(), 'a')
    self.tic()
438

439 440 441
    def toto(self, value):
      self.setTitle(self.getTitle() + value)
    o.__class__.toto = toto
442

443 444 445
    def titi(self, value):
      self.setTitle(self.getTitle() + value)
    o.__class__.titi = titi
446

447 448 449 450
    o.activate(after_method_id = 'titi', activity = activity).toto('b')
    o.activate(activity = activity).titi('c')
    self.tic()
    self.assertEquals(o.getTitle(), 'acb')
451

452 453 454
  def ExpandedMethodWithDeletedSubObject(self, activity):
    """
    Do recursiveReindexObject, then delete a
455
    subobject an see if there is only one activity
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
    in the queue
    """
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not(organisation_module.hasContent(self.company_id2)):
      o2 = organisation_module.newContent(id=self.company_id2)
    o1 =  portal.organisation._getOb(self.company_id)
    o2 =  portal.organisation._getOb(self.company_id2)
    for o in (o1,o2):
      if not(o.hasContent('1')):
        o.newContent(portal_type='Email',id='1')
      if not(o.hasContent('2')):
        o.newContent(portal_type='Email',id='2')
    o1.recursiveReindexObject()
    o2.recursiveReindexObject()
    o1._delOb('2')
472
    self.commit()
473 474
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
475
    self.commit()
476 477 478 479 480 481
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),1)

  def ExpandedMethodWithDeletedObject(self, activity):
    """
    Do recursiveReindexObject, then delete a
482
    subobject an see if there is only one activity
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
    in the queue
    """
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not(organisation_module.hasContent(self.company_id2)):
      o2 = organisation_module.newContent(id=self.company_id2)
    o1 =  portal.organisation._getOb(self.company_id)
    o2 =  portal.organisation._getOb(self.company_id2)
    for o in (o1,o2):
      if not(o.hasContent('1')):
        o.newContent(portal_type='Email',id='1')
      if not(o.hasContent('2')):
        o.newContent(portal_type='Email',id='2')
    o1.recursiveReindexObject()
    o2.recursiveReindexObject()
    organisation_module._delOb(self.company_id2)
499
    self.commit()
500 501
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
502
    self.commit()
503 504 505
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),1)

506 507 508 509 510 511 512 513 514
  def TryAfterTag(self, activity):
    """
      Ensure the order of an execution by a tag
    """
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = portal.organisation._getOb(self.company_id)
515

516 517 518
    o.setTitle('?')
    self.assertEquals(o.getTitle(), '?')
    self.tic()
519

520 521 522 523
    o.activate(after_tag = 'toto', activity = activity).setTitle('b')
    o.activate(tag = 'toto', activity = activity).setTitle('a')
    self.tic()
    self.assertEquals(o.getTitle(), 'b')
524

525
    o.setDefaultActivateParameterDict({'tag': 'toto'})
526 527 528 529 530 531 532
    def titi(self):
      self.setCorporateName(self.getTitle() + 'd')
    o.__class__.titi = titi
    o.activate(after_tag_and_method_id=('toto', 'setTitle'), activity = activity).titi()
    o.activate(activity = activity).setTitle('c')
    self.tic()
    self.assertEquals(o.getCorporateName(), 'cd')
533

534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
  def TryFlushActivityWithAfterTag(self, activity):
    """
      Ensure the order of an execution by a tag
    """
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = portal.organisation._getOb(self.company_id)

    o.setTitle('?')
    o.setDescription('?')
    self.assertEquals(o.getTitle(), '?')
    self.assertEquals(o.getDescription(), '?')
    self.tic()

    o.activate(after_tag = 'toto', activity = activity).setDescription('b')
    o.activate(tag = 'toto', activity = activity).setTitle('a')
552
    self.commit()
553 554 555
    tool = self.getActivityTool()
    self.assertRaises(ActivityFlushError,tool.manageInvoke,o.getPath(),'setDescription')
    tool.manageInvoke(o.getPath(),'setTitle')
556
    self.commit()
557 558 559 560 561 562 563
    self.assertEquals(o.getTitle(), 'a')
    self.assertEquals(o.getDescription(), '?')
    self.tic()
    self.assertEquals(len(tool.getMessageList()),0)
    self.assertEquals(o.getTitle(), 'a')
    self.assertEquals(o.getDescription(), 'b')

Yoshinori Okuji's avatar
Yoshinori Okuji committed
564 565 566 567 568 569 570 571 572
  def CheckScheduling(self, activity):
    """
      Check if active objects with different after parameters are executed in a correct order
    """
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = portal.organisation._getOb(self.company_id)
573

Yoshinori Okuji's avatar
Yoshinori Okuji committed
574 575 576
    o.setTitle('?')
    self.assertEquals(o.getTitle(), '?')
    self.tic()
577

Yoshinori Okuji's avatar
Yoshinori Okuji committed
578 579 580
    def toto(self, s):
      self.setTitle(self.getTitle() + s)
    o.__class__.toto = toto
581

Yoshinori Okuji's avatar
Yoshinori Okuji committed
582
    o.activate(tag = 'toto', activity = activity).toto('a')
583
    self.commit()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
584
    o.activate(after_tag = 'titi', activity = activity).toto('b')
585
    self.commit()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
586 587 588
    o.activate(tag = 'titi', after_tag = 'toto', activity = activity).setTitle('c')
    self.tic()
    self.assertEquals(o.getTitle(), 'cb')
589

590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
  def CheckSchedulingAfterTagList(self, activity):
    """
      Check if active objects with different after parameters are executed in a
      correct order, when after_tag is passed as a list
    """
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = portal.organisation._getOb(self.company_id)

    o.setTitle('')
    self.tic()

    def toto(self, s):
      self.setTitle(self.getTitle() + s)
    o.__class__.toto = toto

    o.activate(tag='A', activity=activity).toto('a')
609
    self.commit()
610
    o.activate(tag='B', activity=activity).toto('b')
611
    self.commit()
612 613 614 615
    o.activate(after_tag=('A', 'B'), activity=activity).setTitle('last')
    self.tic()
    self.assertEquals(o.getTitle(), 'last')

616
  def CheckClearActivities(self, activity, activity_count=1):
617 618 619 620 621 622 623 624 625 626 627
    """
      Check if active objects are held even after clearing the tables.
    """
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    self.tic()

    def check(o):
      message_list = portal.portal_activities.getMessageList()
628
      self.assertEquals(len(message_list), activity_count)
629 630 631
      m = message_list[0]
      self.assertEquals(m.object_path, o.getPhysicalPath())
      self.assertEquals(m.method_id, '_setTitle')
632

633
    o = portal.organisation._getOb(self.company_id)
634 635
    for i in range(activity_count):
      o.activate(activity=activity)._setTitle('foo')
636
    self.commit()
637
    check(o)
638

639
    portal.portal_activities.manageClearActivities()
640
    self.commit()
641
    check(o)
642

643 644 645
    self.tic()

    self.assertEquals(o.getTitle(), 'foo')
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660

  def CheckCountMessageWithTag(self, activity):
    """
      Check countMessageWithTag function.
    """
    portal = self.getPortal()
    portal_activities = portal.portal_activities
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = portal.organisation._getOb(self.company_id)
    o.setTitle('?')
    self.tic()

    o.activate(tag = 'toto', activity = activity).setTitle('a')
661
    self.commit()
662 663 664 665 666 667
    self.assertEquals(o.getTitle(), '?')
    self.assertEquals(portal_activities.countMessageWithTag('toto'), 1)
    self.tic()
    self.assertEquals(o.getTitle(), 'a')
    self.assertEquals(portal_activities.countMessageWithTag('toto'), 0)

668 669 670 671 672 673 674 675 676 677 678 679
  def TryConflictErrorsWhileValidating(self, activity):
    """Try to execute active objects which may throw conflict errors
    while validating, and check if they are still executed."""
    # Make sure that no active object is installed.
    activity_tool = self.getPortal().portal_activities
    activity_tool.manageClearActivities(keep=0)

    # Need an object.
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = organisation_module._getOb(self.company_id)
680
    self.commit()
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
    self.flushAllActivities(silent = 1, loop_size = 10)
    self.assertEquals(len(activity_tool.getMessageList()), 0)

    # Monkey patch Queue to induce conflict errors artificially.
    def validate(self, *args, **kwargs):
      from Products.CMFActivity.Activity.Queue import Queue
      if Queue.current_num_conflict_errors < Queue.conflict_errors_limit:
        Queue.current_num_conflict_errors += 1
        # LOG('TryConflictErrorsWhileValidating', 0, 'causing a conflict error artificially')
        raise ConflictError
      return self.original_validate(*args, **kwargs)
    from Products.CMFActivity.Activity.Queue import Queue
    Queue.original_validate = Queue.validate
    Queue.validate = validate

    try:
      # Test some range of conflict error occurences.
      for i in xrange(10):
        Queue.current_num_conflict_errors = 0
        Queue.conflict_errors_limit = i
        o.activate(activity = activity).getId()
702
        self.commit()
703 704 705 706 707 708 709 710
        self.flushAllActivities(silent = 1, loop_size = i + 10)
        self.assertEquals(len(activity_tool.getMessageList()), 0)
    finally:
      Queue.validate = Queue.original_validate
      del Queue.original_validate
      del Queue.current_num_conflict_errors
      del Queue.conflict_errors_limit

711 712 713 714 715 716 717 718 719 720 721 722
  def TryErrorsWhileFinishingCommitDB(self, activity):
    """Try to execute active objects which may throw conflict errors
    while validating, and check if they are still executed."""
    # Make sure that no active object is installed.
    activity_tool = self.getPortal().portal_activities
    activity_tool.manageClearActivities(keep=0)

    # Need an object.
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = organisation_module._getOb(self.company_id)
723
    self.commit()
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
    self.flushAllActivities(silent = 1, loop_size = 10)
    self.assertEquals(len(activity_tool.getMessageList()), 0)

    from _mysql_exceptions import OperationalError

    # Monkey patch Queue to induce conflict errors artificially.
    def query(self, query_string,*args, **kw):
      # No so nice, this is specific to zsql method
      if query_string.find("REPLACE INTO")>=0:
        raise OperationalError
      else:
        return self.original_query(query_string,*args, **kw)
    from Products.ZMySQLDA.db import DB
    portal = self.getPortal()

    try:
      # Test some range of conflict error occurences.
      organisation_module.recursiveReindexObject()
742
      self.commit()
743 744 745 746 747
      self.assertEquals(len(activity_tool.getMessageList()), 1)
      DB.original_query = DB.query
      DB.query = query
      portal.portal_activities.distribute()
      portal.portal_activities.tic()
748
      self.commit()
749 750 751 752 753 754 755
      DB.query = DB.original_query
      message_list = portal.portal_activities.getMessageList()
      self.assertEquals(len(message_list),1)
    finally:
      DB.query = DB.original_query
      del DB.original_query

756 757 758 759 760 761 762
  def checkIsMessageRegisteredMethod(self, activity):
    activity_tool = self.getPortal().portal_activities
    object_a = self.getOrganisationModule()
    if not object_a.hasContent(self.company_id):
      object_a.newContent(id=self.company_id)
    object_b = object_a._getOb(self.company_id)
    activity_tool.manageClearActivities(keep=0)
763
    self.commit()
764 765 766 767
    # First case: creating the same activity twice must only register one.
    self.assertEquals(len(activity_tool.getMessageList()), 0) # Sanity check
    object_a.activate(activity=activity).getId()
    object_a.activate(activity=activity).getId()
768
    self.commit()
769 770
    self.assertEquals(len(activity_tool.getMessageList()), 1)
    activity_tool.manageClearActivities(keep=0)
771
    self.commit()
772 773 774 775 776
    # Second case: creating activity with same tag must only register one.
    # This behaviour is actually the same as the no-tag behaviour.
    self.assertEquals(len(activity_tool.getMessageList()), 0) # Sanity check
    object_a.activate(activity=activity, tag='foo').getId()
    object_a.activate(activity=activity, tag='foo').getId()
777
    self.commit()
778 779
    self.assertEquals(len(activity_tool.getMessageList()), 1)
    activity_tool.manageClearActivities(keep=0)
780
    self.commit()
781 782 783 784
    # Third case: creating activities with different tags must register both.
    self.assertEquals(len(activity_tool.getMessageList()), 0) # Sanity check
    object_a.activate(activity=activity, tag='foo').getId()
    object_a.activate(activity=activity, tag='bar').getId()
785
    self.commit()
786 787
    self.assertEquals(len(activity_tool.getMessageList()), 2)
    activity_tool.manageClearActivities(keep=0)
788
    self.commit()
789 790 791 792 793
    # Fourth case: creating activities on different objects must register
    # both.
    self.assertEquals(len(activity_tool.getMessageList()), 0) # Sanity check
    object_a.activate(activity=activity).getId()
    object_b.activate(activity=activity).getId()
794
    self.commit()
795 796
    self.assertEquals(len(activity_tool.getMessageList()), 2)
    activity_tool.manageClearActivities(keep=0)
797
    self.commit()
798 799 800 801 802
    # Fifth case: creating activities with different method must register
    # both.
    self.assertEquals(len(activity_tool.getMessageList()), 0) # Sanity check
    object_a.activate(activity=activity).getId()
    object_a.activate(activity=activity).getTitle()
803
    self.commit()
804 805
    self.assertEquals(len(activity_tool.getMessageList()), 2)
    activity_tool.manageClearActivities(keep=0)
806
    self.commit()
807

Yoshinori Okuji's avatar
Yoshinori Okuji committed
808
  def test_01_DeferredSetTitleSQLDict(self, quiet=0, run=run_all_test):
809 810 811
    # Test if we can add a complete sales order
    if not run: return
    if not quiet:
Yoshinori Okuji's avatar
Yoshinori Okuji committed
812
      message = '\nTest Deferred Set Title SQLDict '
813 814
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
815
    self.DeferredSetTitleActivity('SQLDict')
816

Yoshinori Okuji's avatar
Yoshinori Okuji committed
817
  def test_02_DeferredSetTitleSQLQueue(self, quiet=0, run=run_all_test):
818 819 820
    # Test if we can add a complete sales order
    if not run: return
    if not quiet:
Yoshinori Okuji's avatar
Yoshinori Okuji committed
821
      message = '\nTest Deferred Set Title SQLQueue '
822 823
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
824
    self.DeferredSetTitleActivity('SQLQueue')
825

Sebastien Robin's avatar
Sebastien Robin committed
826 827 828 829 830 831 832
  def test_05_InvokeAndCancelSQLDict(self, quiet=0, run=run_all_test):
    # Test if we can add a complete sales order
    if not run: return
    if not quiet:
      message = '\nTest Invoke And Cancel SQLDict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
833
    self.InvokeAndCancelActivity('SQLDict')
Sebastien Robin's avatar
Sebastien Robin committed
834 835 836 837 838 839 840 841

  def test_06_InvokeAndCancelSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we can add a complete sales order
    if not run: return
    if not quiet:
      message = '\nTest Invoke And Cancel SQLQueue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
842
    self.InvokeAndCancelActivity('SQLQueue')
Sebastien Robin's avatar
Sebastien Robin committed
843

844 845 846 847 848 849 850 851 852 853
  def test_09_CallOnceWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nCall Once With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CallOnceWithActivity('SQLDict')

  def test_10_CallOnceWithSQLQueue(self, quiet=0, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
854 855 856 857 858 859
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nCall Once With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
860 861
    self.CallOnceWithActivity('SQLQueue')

862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879
  def test_13_TryMessageWithErrorOnSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Message With Error On SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryMessageWithErrorOnActivity('SQLDict')

  def test_14_TryMessageWithErrorOnSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Message With Error On SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryMessageWithErrorOnActivity('SQLQueue')

880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
  def test_17_TryFlushActivityWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Flush Activity With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryFlushActivity('SQLDict')

  def test_18_TryFlushActivityWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Flush Activity With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryFlushActivity('SQLQueue')

898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
  def test_21_TryActivateInsideFlushWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Activate Inside Flush With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivateInsideFlush('SQLDict')

  def test_22_TryActivateInsideFlushWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Activate Inside Flush With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivateInsideFlush('SQLQueue')

  def test_25_TryTwoMethodsWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Two Methods With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryTwoMethods('SQLDict')

  def test_26_TryTwoMethodsWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Two Methods With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryTwoMethods('SQLQueue')

  def test_29_TryTwoMethodsAndFlushThemWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Two Methods And Flush Them With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryTwoMethodsAndFlushThem('SQLDict')

  def test_30_TryTwoMethodsAndFlushThemWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Two Methods And Flush Them With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryTwoMethodsAndFlushThem('SQLQueue')

952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
  def test_33_TryActivateFlushActivateTicWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Activate Flush Activate Tic With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivateFlushActivateTic('SQLDict')

  def test_34_TryActivateFlushActivateTicWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Activate Flush Activate Tic With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivateFlushActivateTic('SQLQueue')

  def test_37_TryActivateFlushActivateTicWithMultipleActivities(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Activate Flush Activate Tic With MultipleActivities '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivateFlushActivateTic('SQLQueue',second='SQLDict')
    self.TryActivateFlushActivateTic('SQLDict',second='SQLQueue')

  def test_38_TryCommitSubTransactionWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Commit Sub Transaction With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivateFlushActivateTic('SQLDict',commit_sub=1)

  def test_39_TryCommitSubTransactionWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Commit Sub Transaction With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivateFlushActivateTic('SQLQueue',commit_sub=1)

998 999 1000 1001 1002 1003 1004
  def test_42_TryRenameObjectWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Rename Object With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
1005
    self.DeferredSetTitleWithRenamedObject('SQLDict')
1006 1007 1008 1009 1010 1011 1012 1013

  def test_43_TryRenameObjectWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Rename Object With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
1014
    self.DeferredSetTitleWithRenamedObject('SQLQueue')
1015 1016 1017 1018 1019 1020 1021 1022 1023

  def test_46_TryActiveProcessWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Active Process With SQL Dict '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActiveProcess('SQLDict')
Sebastien Robin's avatar
Sebastien Robin committed
1024

1025 1026 1027 1028 1029 1030 1031 1032
  def test_47_TryActiveProcessWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if we call methods only once
    if not run: return
    if not quiet:
      message = '\nTry Active Process With SQL Queue '
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActiveProcess('SQLQueue')
Sebastien Robin's avatar
Sebastien Robin committed
1033

1034 1035 1036 1037
  def test_54_TryAfterMethodIdWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if after_method_id can be used
    if not run: return
    if not quiet:
1038
      message = '\nTry Active Method After Another Activate Method With SQLDict'
1039 1040 1041
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryMethodAfterMethod('SQLDict')
1042

1043 1044 1045 1046 1047 1048 1049 1050
  def test_55_TryAfterMethodIdWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if after_method_id can be used
    if not run: return
    if not quiet:
      message = '\nTry Active Method After Another Activate Method With SQLQueue'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryMethodAfterMethod('SQLQueue')
1051

1052
  def test_56_TryCallActivityWithRightUser(self, quiet=0, run=run_all_test):
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
    # Test if me execute methods with the right user
    # This should be independant of the activity used
    if not run: return
    if not quiet:
      message = '\nTry Call Activity With Right User'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    # We are first logged as seb
    portal = self.getPortal()
    organisation =  portal.organisation._getOb(self.company_id)
    # Add new user toto
    uf = self.getPortal().acl_users
    uf._doAddUser('toto', '', ['Manager'], [])
    user = uf.getUserById('toto').__of__(uf)
    newSecurityManager(None, user)
    # Execute something as toto
    organisation.activate().newContent(portal_type='Email',id='email')
    # Then execute activities as seb
    user = uf.getUserById('seb').__of__(uf)
    newSecurityManager(None, user)
1073
    self.commit()
1074 1075 1076 1077 1078 1079
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
    email = organisation.get('email')
    # Check if what we did was executed as toto
    self.assertEquals(email.getOwnerInfo()['id'],'toto')

1080 1081 1082 1083 1084 1085 1086 1087
  def test_57_ExpandedMethodWithDeletedSubObject(self, quiet=0, run=run_all_test):
    # Test if after_method_id can be used
    if not run: return
    if not quiet:
      message = '\nTry Expanded Method With Deleted Sub Object'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.ExpandedMethodWithDeletedSubObject('SQLDict')
1088

1089 1090 1091 1092 1093 1094 1095 1096
  def test_58_ExpandedMethodWithDeletedObject(self, quiet=0, run=run_all_test):
    # Test if after_method_id can be used
    if not run: return
    if not quiet:
      message = '\nTry Expanded Method With Deleted Object'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.ExpandedMethodWithDeletedObject('SQLDict')
Sebastien Robin's avatar
Sebastien Robin committed
1097

1098 1099 1100 1101 1102 1103 1104 1105 1106
  def test_59_TryAfterTagWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if after_tag can be used
    if not run: return
    if not quiet:
      message = '\nTry After Tag With SQL Dict'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryAfterTag('SQLDict')

1107
  def test_60_TryAfterTagWithSQLQueue(self, quiet=0, run=run_all_test):
1108 1109 1110 1111 1112 1113 1114 1115
    # Test if after_tag can be used
    if not run: return
    if not quiet:
      message = '\nTry After Tag With SQL Queue'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryAfterTag('SQLQueue')

Yoshinori Okuji's avatar
Yoshinori Okuji committed
1116 1117 1118 1119 1120 1121 1122 1123 1124
  def test_61_CheckSchedulingWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if scheduling is correct with SQLDict
    if not run: return
    if not quiet:
      message = '\nCheck Scheduling With SQL Dict'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckScheduling('SQLDict')

1125
  def test_62_CheckSchedulingWithSQLQueue(self, quiet=0, run=run_all_test):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
1126 1127 1128 1129 1130 1131 1132 1133
    # Test if scheduling is correct with SQLQueue
    if not run: return
    if not quiet:
      message = '\nCheck Scheduling With SQL Queue'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckScheduling('SQLQueue')

1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
  def test_61_CheckSchedulingAfterTagListWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if scheduling is correct with SQLDict
    if not run: return
    if not quiet:
      message = '\nCheck Scheduling After Tag List With SQL Dict'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckSchedulingAfterTagList('SQLDict')

  def test_62_CheckSchedulingWithAfterTagListSQLQueue(self, quiet=0, run=run_all_test):
    # Test if scheduling is correct with SQLQueue
    if not run: return
    if not quiet:
      message = '\nCheck Scheduling After Tag List With SQL Queue'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckSchedulingAfterTagList('SQLQueue')

1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
  def test_63_CheckClearActivitiesWithSQLDict(self, quiet=0, run=run_all_test):
    # Test if clearing tables does not remove active objects with SQLDict
    if not run: return
    if not quiet:
      message = '\nCheck Clearing Activities With SQL Dict'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckClearActivities('SQLDict')

  def test_64_CheckClearActivitiesWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if clearing tables does not remove active objects with SQLQueue
    if not run: return
    if not quiet:
      message = '\nCheck Clearing Activities With SQL Queue'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
1168
    self.CheckClearActivities('SQLQueue', activity_count=2)
1169

1170
  def flushAllActivities(self, silent=0, loop_size=1000):
1171 1172 1173 1174 1175 1176 1177 1178
    """Executes all messages until the queue only contains failed
    messages.
    """
    activity_tool = self.getPortal().portal_activities
    loop_count=0
    # flush activities
    while 1:
      loop_count += 1
1179 1180 1181
      if loop_count >= loop_size:
        if silent:
          return
1182 1183 1184 1185
        self.fail('flushAllActivities maximum loop count reached')

      activity_tool.distribute(node_count=1)
      activity_tool.tic(processing_node=1)
1186

1187 1188 1189 1190 1191 1192 1193
      finished = 1
      for message in activity_tool.getMessageList():
        if message.processing_node not in (INVOKE_ERROR_STATE,
                                           VALIDATE_ERROR_STATE):
          finished = 0

      activity_tool.timeShift(3 * VALIDATION_ERROR_DELAY)
1194
      self.commit()
1195
      if finished:
1196
        return
1197 1198 1199 1200 1201 1202 1203

  def test_65_TestMessageValidationAndFailedActivities(self,
                                              quiet=0, run=run_all_test):
    """after_method_id and failed activities.

    Tests that if we have an active method scheduled by
    after_method_id and a failed activity with this method id, the
1204 1205 1206 1207 1208 1209
    method is NOT executed.

    Note: earlier version of this test checked exactly the contrary, but it
    was eventually agreed that this was a bug. If an activity fails, all the
    activities that depend on it should be block until the first one is
    resolved."""
1210 1211 1212 1213 1214 1215
    if not run: return
    if not quiet:
      message = '\nafter_method_id and failed activities'
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
    activity_tool = self.getPortal().portal_activities
1216
    original_title = 'something'
1217
    obj = self.getPortal().organisation_module.newContent(
1218 1219 1220
                    portal_type='Organisation',
                    title=original_title)

1221 1222 1223 1224 1225 1226 1227 1228
    # Monkey patch Organisation to add a failing method
    def failingMethod(self):
      raise ValueError, 'This method always fail'
    Organisation.failingMethod = failingMethod

    # Monkey patch Message not to send failure notification emails
    from Products.CMFActivity.ActivityTool import Message
    originalNotifyUser = Message.notifyUser
1229
    def notifyUserSilent(self, *args, **kw):
1230 1231 1232 1233 1234 1235
      pass
    Message.notifyUser = notifyUserSilent

    activity_list = ['SQLQueue', 'SQLDict', ]
    for activity in activity_list:
      # reset
1236 1237
      activity_tool.manageClearActivities(keep=0)
      obj.setTitle(original_title)
1238
      self.commit()
1239 1240 1241 1242

      # activate failing message and flush
      for fail_activity in activity_list:
        obj.activate(activity = fail_activity).failingMethod()
1243
      self.commit()
1244 1245 1246 1247 1248 1249 1250 1251 1252
      self.flushAllActivities(silent=1, loop_size=100)
      full_message_list = activity_tool.getMessageList()
      remaining_messages = [a for a in full_message_list if a.method_id !=
          'failingMethod']
      if len(full_message_list) != 2:
        self.fail('failingMethod should not have been flushed')
      if len(remaining_messages) != 0:
        self.fail('Activity tool should have no other remaining messages')

1253 1254 1255 1256
      # activate our message
      new_title = 'nothing'
      obj.activate(after_method_id = ['failingMethod'],
                   activity = activity ).setTitle(new_title)
1257
      self.commit()
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
      self.flushAllActivities(silent=1, loop_size=100)
      full_message_list = activity_tool.getMessageList()
      remaining_messages = [a for a in full_message_list if a.method_id !=
          'failingMethod']
      if len(full_message_list) != 3:
        self.fail('failingMethod should not have been flushed')
      if len(remaining_messages) != 1:
        self.fail('Activity tool should have one blocked setTitle activity')
      self.assertEquals(remaining_messages[0].activity_kw['after_method_id'],
          ['failingMethod'])
      self.assertEquals(obj.getTitle(), original_title)

    # restore notification and flush failed and blocked activities
1271
    Message.notifyUser = originalNotifyUser
1272
    activity_tool.manageClearActivities(keep=0)
1273

1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
  def test_66_TestCountMessageWithTagWithSQLDict(self, quiet=0, run=run_all_test):
    """
      Test new countMessageWithTag function with SQLDict.
    """
    if not run: return
    if not quiet:
      message = '\nCheck countMessageWithTag'
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
    self.CheckCountMessageWithTag('SQLDict')

1285 1286
  def test_67_TestCancelFailedActiveObject(self, quiet=0, run=run_all_test):
    """Cancel an active object to make sure that it does not refer to
1287 1288 1289 1290
    a persistent object.

    XXX: this test fails if run first
    """
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
    if not run: return
    if not quiet:
      message = '\nTest if it is possible to safely cancel an active object'
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
    activity_tool = self.getPortal().portal_activities
    activity_tool.manageClearActivities(keep=0)

    original_title = 'something'
    obj = self.getPortal().organisation_module.newContent(
                    portal_type='Organisation',
                    title=original_title)

    # Monkey patch Organisation to add a failing method
    def failingMethod(self):
      raise ValueError, 'This method always fail'
    Organisation.failingMethod = failingMethod

    # Monkey patch Message not to send failure notification emails
    from Products.CMFActivity.ActivityTool import Message
    originalNotifyUser = Message.notifyUser
1312
    def notifyUserSilent(self, *args, **kw):
1313 1314 1315 1316
      pass
    Message.notifyUser = notifyUserSilent

    # First, index the object.
1317
    self.commit()
1318 1319 1320 1321 1322
    self.flushAllActivities(silent=1, loop_size=100)
    self.assertEquals(len(activity_tool.getMessageList()), 0)

    # Insert a failing active object.
    obj.activate().failingMethod()
1323
    self.commit()
1324 1325 1326
    self.assertEquals(len(activity_tool.getMessageList()), 1)

    # Just wait for the active object to be abandoned.
1327
    self.flushAllActivities(silent=1, loop_size=100)
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
    self.assertEquals(len(activity_tool.getMessageList()), 1)
    self.assertEquals(activity_tool.getMessageList()[0].processing_node, 
                      INVOKE_ERROR_STATE)

    # Make sure that persistent objects are not present in the connection
    # cache to emulate a restart of Zope. So all volatile attributes will
    # be flushed, and persistent objects will be reloaded.
    activity_tool._p_jar._resetCache()

    # Cancel it via the management interface.
    message = activity_tool.getMessageList()[0]
    activity_tool.manageCancel(message.object_path, message.method_id)
1340
    self.commit()
1341 1342
    self.assertEquals(len(activity_tool.getMessageList()), 0)

1343
  def test_68_RetryMessageExecution(self, quiet=0):
1344
    if not quiet:
1345
      message = '\nCheck number of executions of failing activities'
1346 1347
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
    activity_tool = self.portal.portal_activities
    self.assertFalse(activity_tool.getMessageList())
    exec_count = [0]
    # priority does not matter anymore
    priority = random.Random().randint
    def doSomething(self, retry_list):
      i = exec_count[0]
      exec_count[0] = i + 1
      conflict, edit_kw = retry_list[i]
      if edit_kw:
        self.getActivityRuntimeEnvironment().edit(**edit_kw)
      if conflict is not None:
1360
        raise ConflictError if conflict else Exception
1361
    def check(retry_list, **activate_kw):
1362 1363 1364
      fail = retry_list[-1][0] is not None and 1 or 0
      for activity in 'SQLDict', 'SQLQueue':
        exec_count[0] = 0
1365 1366
        activity_tool.activate(activity=activity, priority=priority(1,6),
                               **activate_kw).doSomething(retry_list)
1367
        self.commit()
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
        self.flushAllActivities(silent=1)
        self.assertEqual(len(retry_list), exec_count[0])
        self.assertEqual(fail, len(activity_tool.getMessageList()))
        self.portal.portal_activities.manageCancel(
          activity_tool.getPhysicalPath(), 'doSomething')
    activity_tool.__class__.doSomething = doSomething
    try:
      ## Default behaviour
      # Usual successful case: activity is run only once
      check([(None, None)])
      # Usual error case: activity is run 6 times before being frozen
      check([(False, None)] * 6)
      # On ConflictError, activity is reexecuted without increasing retry count
      check([(True, None)] * 10 + [(None, None)])
      check([(True, None), (False, None)] * 6)
      ## Customized behaviour
      # Do not retry
      check([(False, {'max_retry': 0})])
      # ... even in case of ConflictError
      check([(True, {'max_retry': 0}),
             (True, {'max_retry': 0, 'conflict_retry': 0})])
1389
      check([(True, None)] * 6, conflict_retry=False)
1390 1391 1392 1393 1394 1395 1396 1397 1398
      # Customized number of retries
      for n in 3, 9:
        check([(False, {'max_retry': n})] * n + [(None, None)])
        check([(False, {'max_retry': n})] * (n + 1))
      # Infinite retry
      for n in 3, 9:
        check([(False, {'max_retry': None})] * n + [(None, None)])
        check([(False, {'max_retry': None})] * n + [(False, {'max_retry': 0})])
      check([(False, {'max_retry': None})] * 9 + [(False, None)])
1399

1400 1401 1402
    finally:
      del activity_tool.__class__.doSomething
    self.assertFalse(activity_tool.getMessageList())
1403

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
  def test_70_TestConflictErrorsWhileValidatingWithSQLDict(self, quiet=0, run=run_all_test):
    """
      Test if conflict errors spoil out active objects with SQLDict.
    """
    if not run: return
    if not quiet:
      message = '\nTest Conflict Errors While Validating With SQLDict'
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
    self.TryConflictErrorsWhileValidating('SQLDict')

  def test_71_TestConflictErrorsWhileValidatingWithSQLQueue(self, quiet=0, run=run_all_test):
    """
      Test if conflict errors spoil out active objects with SQLQueue.
    """
    if not run: return
    if not quiet:
      message = '\nTest Conflict Errors While Validating With SQLQueue'
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
    self.TryConflictErrorsWhileValidating('SQLQueue')

1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
  def test_72_TestErrorsWhileFinishingCommitDBWithSQLDict(self, quiet=0, run=run_all_test):
    """
    """
    if not run: return
    if not quiet:
      message = '\nTest Errors While Finishing Commit DB With SQLDict'
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
    self.TryErrorsWhileFinishingCommitDB('SQLDict')

  def test_73_TestErrorsWhileFinishingCommitDBWithSQLQueue(self, quiet=0, run=run_all_test):
    """
    """
    if not run: return
    if not quiet:
      message = '\nTest Errors While Finishing Commit DB With SQLQueue'
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
    self.TryErrorsWhileFinishingCommitDB('SQLQueue')

1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
  def test_74_TryFlushActivityWithAfterTagSQLDict(self, quiet=0, run=run_all_test):
    # Test if after_tag can be used
    if not run: return
    if not quiet:
      message = '\nTry Flus Activity With After Tag With SQL Dict'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryFlushActivityWithAfterTag('SQLDict')

  def test_75_TryFlushActivityWithAfterTagWithSQLQueue(self, quiet=0, run=run_all_test):
    # Test if after_tag can be used
    if not run: return
    if not quiet:
      message = '\nTry Flush Activity With After Tag With SQL Queue'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryFlushActivityWithAfterTag('SQLQueue')

1464 1465 1466 1467 1468 1469 1470 1471 1472
  def test_76_ActivateKwForNewContent(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck reindex message uses activate_kw passed to newContent'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)

    o1 = self.getOrganisationModule().newContent(
                                  activate_kw=dict(tag='The Tag'))
1473
    self.commit()
1474 1475 1476 1477 1478 1479
    messages_for_o1 = [m for m in self.getActivityTool().getMessageList()
                       if m.object_path == o1.getPhysicalPath()]
    self.assertNotEquals(0, len(messages_for_o1))
    for m in messages_for_o1:
      self.assertEquals(m.activity_kw.get('tag'), 'The Tag')

1480

1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
  def test_77_FlushAfterMultipleActivate(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck all message are flushed in SQLDict'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    orga_module = self.getOrganisationModule()
    p = orga_module.newContent(portal_type='Organisation')
    self.tic()
    self.assertEqual(p.getDescription(), "")
    activity_tool = self.getPortal().portal_activities

    def updateDesc(self):
      d =self.getDescription()
      self.setDescription(d+'a')
    Organisation.updateDesc = updateDesc

    self.assertEqual(len(activity_tool.getMessageList()), 0)
    # First check dequeue read same message only once
    for i in xrange(10):
      p.activate(activity="SQLDict").updateDesc()
1502
      self.commit()
1503

1504
    self.assertEqual(len(activity_tool.getMessageList()), 10)
1505 1506 1507 1508 1509 1510
    self.tic()
    self.assertEqual(p.getDescription(), "a")

    # Check if there is pending activity after deleting an object
    for i in xrange(10):
      p.activate(activity="SQLDict").updateDesc()
1511
      self.commit()
1512 1513

    self.assertEqual(len(activity_tool.getMessageList()), 10)
1514
    activity_tool.flush(p, invoke=0)
1515
    self.commit()
1516 1517
    self.assertEqual(len(activity_tool.getMessageList()), 0)

1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
  def test_78_IsMessageRegisteredSQLDict(self, quiet=0, run=run_all_test):
    """
      This test tests behaviour of IsMessageRegistered method.
    """
    if not run: return
    if not quiet:
      message = '\nTest IsMessageRegistered behaviour with SQLDict'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.checkIsMessageRegisteredMethod('SQLDict')

1529 1530
  def test_79_AbortTransactionSynchronously(self, quiet=0, run=run_all_test):
    """
1531 1532
      This test checks if transaction.abort() synchronizes connections. It
      didn't do so back in Zope 2.7
1533 1534 1535
    """
    if not run: return
    if not quiet:
1536
      message = '\nTest Aborting Transaction Synchronizes'
1537 1538 1539 1540 1541 1542 1543 1544
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)

    # Make a new persistent object, and commit it so that an oid gets
    # assigned.
    module = self.getOrganisationModule()
    organisation = module.newContent(portal_type = 'Organisation')
    organisation_id = organisation.getId()
1545
    self.commit()
1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
    organisation = module[organisation_id]

    # Now fake a read conflict.
    from ZODB.POSException import ReadConflictError
    tid = organisation._p_serial
    oid = organisation._p_oid
    conn = organisation._p_jar
    if getattr(conn, '_mvcc', 0):
      conn._mvcc = 0 # XXX disable MVCC forcibly
    try:
      conn.db().invalidate({oid: tid})
    except TypeError:
      conn.db().invalidate(tid, {oid: tid})
    conn._cache.invalidate(oid)

1561 1562
    # Access to invalidated object in non-MVCC connections should raise a
    # conflict error
1563 1564
    organisation = module[organisation_id]
    self.assertRaises(ReadConflictError, getattr, organisation, 'uid')
1565 1566

    # In Zope 2.7, abort does not sync automatically, so even after abort,
1567 1568
    # ReadConflictError would be raised. But in Zope 2.8, this is automatic.

1569
    self.abort()
1570 1571
    getattr(organisation, 'uid')

1572

1573
  def callWithGroupIdParamater(self, activity, quiet, run):
1574 1575
    if not run: return
    if not quiet:
1576
      message = '\nTest Activity with group_id parameter (%s)' % activity
1577 1578 1579 1580 1581 1582
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)

    portal = self.getPortal()    
    organisation =  portal.organisation._getOb(self.company_id)
    # Defined a group method
1583
    foobar_list = []
1584
    def setFoobar(self, object_list):
1585
      foobar_list.append(len(object_list))
1586 1587
      for obj, args, kw, _ in object_list:
        obj.foobar = getattr(obj.aq_base, 'foobar', 0) + kw.get('number', 1)
1588
    from Products.ERP5Type.Core.Folder import Folder
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
    Folder.setFoobar = setFoobar    

    def getFoobar(self):
      return (getattr(self,'foobar',0))
    Organisation.getFoobar = getFoobar

    organisation.foobar = 0
    self.assertEquals(0,organisation.getFoobar())

    # Test group_method_id is working without group_id
    for x in xrange(5):
1600
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar").reindexObject(number=1)
1601
      self.commit()
1602 1603 1604 1605 1606

    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),5)
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
1607 1608
    expected = dict(SQLDict=1, SQLQueue=5)[activity]
    self.assertEquals(expected, organisation.getFoobar())
1609 1610 1611 1612


    # Test group_method_id is working with one group_id defined
    for x in xrange(5):
1613
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="1").reindexObject(number=1)
1614
      self.commit()
1615 1616 1617 1618 1619

    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),5)
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
1620 1621 1622 1623
    self.assertEquals(expected * 2, organisation.getFoobar())

    self.assertEquals([expected, expected], foobar_list)
    del foobar_list[:]
1624 1625 1626

    # Test group_method_id is working with many group_id defined
    for x in xrange(5):
1627
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="1").reindexObject(number=1)
1628
      self.commit()
1629
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="2").reindexObject(number=3)
1630
      self.commit()
1631
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="1").reindexObject(number=1)
1632
      self.commit()
1633
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="3").reindexObject(number=5)
1634
      self.commit()
1635 1636 1637 1638 1639

    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list),20)
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
1640 1641 1642 1643
    self.assertEquals(dict(SQLDict=11, SQLQueue=60)[activity],
                      organisation.getFoobar())
    self.assertEquals(dict(SQLDict=[1, 1, 1], SQLQueue=[5, 5, 10])[activity],
                      sorted(foobar_list))
1644 1645
    message_list = portal.portal_activities.getMessageList()
    self.assertEquals(len(message_list), 0)
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658

  def test_80a_CallWithGroupIdParamaterSQLDict(self, quiet=0, run=run_all_test):
    """
    Test that group_id parameter is used to separate execution of the same method
    """
    self.callWithGroupIdParamater('SQLDict', quiet=quiet, run=run)

  def test_80b_CallWithGroupIdParamaterSQLQueue(self, quiet=0,
                                                run=run_all_test):
    """
    Test that group_id parameter is used to separate execution of the same method
    """
    self.callWithGroupIdParamater('SQLQueue', quiet=quiet, run=run)
1659

1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
  def test_81_ActivateKwForWorkflowTransition(self, quiet=0, run=run_all_test):
    """
    Test call of a workflow transition with activate_kw parameter propagate them
    """
    if not run: return
    if not quiet:
      message = '\nCheck reindex message uses activate_kw passed to workflow transition'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    o1 = self.getOrganisationModule().newContent()
    self.tic()
    o1.validate(activate_kw=dict(tag='The Tag'))
1672
    self.commit()
1673 1674 1675 1676 1677 1678
    messages_for_o1 = [m for m in self.getActivityTool().getMessageList()
                       if m.object_path == o1.getPhysicalPath()]
    self.assertNotEquals(0, len(messages_for_o1))
    for m in messages_for_o1:
      self.assertEquals(m.activity_kw.get('tag'), 'The Tag')
  
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
  def test_82_LossOfVolatileAttribute(self, quiet=0, run=run_all_test):
    """
    Test that the loss of volatile attribute doesn't loose activities
    """
    if not run: return
    if not quiet:
      message = '\nCheck loss of volatile attribute doesn\'t cause message to be lost'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
    activity_tool = self.getActivityTool()
    message_list = activity_tool.getMessageList()
    self.assertEquals(len(message_list), 0)
    def delete_volatiles():
      for property_id in activity_tool.__dict__.keys():
        if property_id.startswith('_v_'):
          delattr(activity_tool, property_id)
    organisation_module = self.getOrganisationModule()
    active_organisation_module = organisation_module.activate()
    delete_volatiles()
    # Cause a message to be created
    # If the buffer cannot be created, this will raise
    active_organisation_module.getTitle()
    delete_volatiles()
    # Another activity to check that first one did not get lost even if volatile disapears
    active_organisation_module.getId()
1705
    self.commit()
1706 1707
    message_list = activity_tool.getMessageList()
    self.assertEquals(len(message_list), 2)
1708

1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
  def test_83_ActivityModificationsViaCMFActivityConnectionRolledBackOnErrorSQLDict(self, quiet=0, run=run_all_test):
    """
      When an activity modifies tables through CMFActivity SQL connection and
      raises, check that its changes are correctly rolled back.
    """
    if not run: return
    if not quiet:
      message = '\nCheck activity modifications via CMFActivity connection are rolled back on error (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
1720
    activity_tool = self.getActivityTool()
1721
    def modifySQLAndFail(self, object_list):
1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
      # Only create the dummy activity if none is present: we would just
      # generate missleading errors (duplicate uid).
      if activity_tool.countMessage(method_id='dummy_activity') == 0:
        # Add a dumy activity which will not be executed
        # Modified table does not matter
        method_id = 'dummy_activity'
        path = '/'.join(self.getPhysicalPath())
        message = Message(self, None, {}, method_id, (), {})
        pickled_message = pickle.dumps(message)
        self.SQLDict_writeMessageList(
          uid_list=[0], # This uid is never automaticaly assigned (starts at 1)
          date_list=[DateTime().Date()],
          path_list=[path],
1735
          active_process_uid=[None],
1736 1737 1738 1739
          method_id_list=[method_id],
          message_list=[pickled_message],
          priority_list=[1],
          processing_node_list=[-2],
1740
          group_method_id_list=['\0'],
1741
          tag_list=[''],
1742 1743
          order_validation_text_list=[''],
          serialization_tag_list=[''],
1744
          )
1745 1746
      # Mark first entry as failed
      del object_list[0][3]
1747 1748
    def dummy(self):
      pass
1749 1750 1751 1752 1753 1754 1755 1756
    try:
      Organisation.modifySQLAndFail = modifySQLAndFail
      Organisation.dummy = dummy
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      group_method_id = '%s/modifySQLAndFail' % (obj.getPath(), )
      obj.activate(activity='SQLDict', group_method_id=group_method_id).dummy()
      obj2 = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      obj2.activate(activity='SQLDict', group_method_id=group_method_id).dummy()
1757
      self.commit()
1758 1759 1760 1761 1762
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEquals(activity_tool.countMessage(method_id='dummy_activity'), 0)
    finally:
      delattr(Organisation, 'modifySQLAndFail')
      delattr(Organisation, 'dummy')
1763

1764
  def test_84_ActivityModificationsViaCMFActivityConnectionRolledBackOnErrorSQLQueue(self, quiet=0, run=run_all_test):
1765 1766 1767 1768 1769 1770
    """
      When an activity modifies tables through CMFActivity SQL connection and
      raises, check that its changes are correctly rolled back.
    """
    if not run: return
    if not quiet:
1771
      message = '\nCheck activity modifications via CMFActivity connection are rolled back on error (SQLQueue)'
1772 1773 1774
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
    activity_tool = self.getActivityTool()
    def modifySQLAndFail(self):
      # Only create the dummy activity if none is present: we would just
      # generate missleading errors (duplicate uid).
      if activity_tool.countMessage(method_id='dummy_activity') == 0:
        # Add a dumy activity which will not be executed
        # Modified table does not matter
        method_id = 'dummy_activity'
        path = '/'.join(self.getPhysicalPath())
        message = Message(self, None, {}, method_id, (), {})
        pickled_message = pickle.dumps(message)
        self.SQLDict_writeMessageList(
          uid_list=[0], # This uid is never automaticaly assigned (starts at 1)
          date_list=[DateTime().Date()],
          path_list=[path],
          method_id_list=[method_id],
          message_list=[pickled_message],
          priority_list=[1],
          processing_node_list=[-2],
1794
          group_method_id_list=['\0'],
1795
          tag_list=[''],
1796 1797
          order_validation_text_list=[''],
          serialization_tag_list=['']
1798 1799 1800
          )
      # Fail
      raise ValueError, 'This method always fail'
1801 1802 1803 1804
    try:
      Organisation.modifySQLAndFail = modifySQLAndFail
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      obj.activate(activity='SQLQueue').modifySQLAndFail()
1805
      self.commit()
1806 1807 1808
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEquals(activity_tool.countMessage(method_id='dummy_activity'), 0)
    finally:
Vincent Pelletier's avatar
Vincent Pelletier committed
1809
      delattr(Organisation, 'modifySQLAndFail')
1810

1811
  def test_85_MessagePathMustBeATuple(self, quiet=0, run=run_all_test):
1812
    """
1813 1814 1815 1816
      Message property 'object_path' must be a tuple, whatever it is generated from.
      Possible path sources are:
       - bare string
       - object
1817 1818 1819
    """
    if not run: return
    if not quiet:
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837
      message = '\nCheck that message property \'object_path\' is a tuple, whatever it is generated from.'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    def check(value):
      message = Message(value, None, {}, 'dummy', (), {})
      self.assertTrue(isinstance(message.object_path, tuple))
    # Bare string
    check('/foo/bar')
    # Object
    check(self.getPortalObject().person_module)

  def test_86_ActivityToolInvokeGroupFailureDoesNotCommitCMFActivitySQLConnectionSQLDict(self, quiet=0, run=run_all_test):
    """
      Check that CMFActivity SQL connection is rollback if activity_tool.invokeGroup raises.
    """
    if not run: return
    if not quiet:
      message = '\nCheck that activity modifications via CMFActivity connection are rolled back on ActivityTool error (SQLDict)'
1838 1839 1840
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859
    activity_tool = self.getActivityTool()
    def modifySQLAndFail(self, *arg, **kw):
      # Only create the dummy activity if none is present: we would just
      # generate missleading errors (duplicate uid).
      if activity_tool.countMessage(method_id='dummy_activity') == 0:
        # Add a dumy activity which will not be executed
        # Modified table does not matter
        method_id = 'dummy_activity'
        path = '/'.join(self.getPhysicalPath())
        message = Message(self, None, {}, method_id, (), {})
        pickled_message = pickle.dumps(message)
        self.SQLDict_writeMessageList(
          uid_list=[0], # This uid is never automaticaly assigned (starts at 1)
          date_list=[DateTime().Date()],
          path_list=[path],
          method_id_list=[method_id],
          message_list=[pickled_message],
          priority_list=[1],
          processing_node_list=[-2],
1860
          group_method_id_list=['\0'],
1861
          tag_list=[''],
1862 1863
          order_validation_text_list=[''],
          serialization_tag_list=[''],
1864 1865 1866 1867 1868
          )
      # Fail
      raise ValueError, 'This method always fail'
    def dummy(self):
      pass
1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
    invoke = activity_tool.__class__.invoke
    invokeGroup = activity_tool.__class__.invokeGroup
    try: 
      activity_tool.__class__.invoke = modifySQLAndFail
      activity_tool.__class__.invokeGroup = modifySQLAndFail
      Organisation.dummy = dummy
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      group_method_id = '%s/dummy' % (obj.getPath(), )
      obj.activate(activity='SQLDict', group_method_id=group_method_id).dummy()
      obj2 = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      obj2.activate(activity='SQLDict', group_method_id=group_method_id).dummy()
1880
      self.commit()
1881 1882 1883 1884 1885 1886
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEquals(activity_tool.countMessage(method_id='dummy_activity'), 0)
    finally:
      delattr(Organisation, 'dummy')
      activity_tool.__class__.invoke = invoke
      activity_tool.__class__.invokeGroup = invokeGroup
1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
  
  def test_87_ActivityToolInvokeFailureDoesNotCommitCMFActivitySQLConnectionSQLQueue(self, quiet=0, run=run_all_test):
    """
      Check that CMFActivity SQL connection is rollback if activity_tool.invoke raises.
    """
    if not run: return
    if not quiet:
      message = '\nCheck that activity modifications via CMFActivity connection are rolled back on ActivityTool error (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
    activity_tool = self.getActivityTool()
    def modifySQLAndFail(self, *args, **kw):
      # Only create the dummy activity if none is present: we would just
      # generate missleading errors (duplicate uid).
      if activity_tool.countMessage(method_id='dummy_activity') == 0:
        # Add a dumy activity which will not be executed
        # Modified table does not matter
        method_id = 'dummy_activity'
        path = '/'.join(self.getPhysicalPath())
        message = Message(self, None, {}, method_id, (), {})
        pickled_message = pickle.dumps(message)
        self.SQLDict_writeMessageList(
          uid_list=[0], # This uid is never automaticaly assigned (starts at 1)
          date_list=[DateTime().Date()],
          path_list=[path],
          method_id_list=[method_id],
          message_list=[pickled_message],
          priority_list=[1],
          processing_node_list=[-2],
1917
          group_method_id_list=['\0'],
1918
          tag_list=[''],
1919 1920
          order_validation_text_list=[''],
          serialization_tag_list=[''],
1921 1922 1923 1924 1925
          )
      # Fail
      raise ValueError, 'This method always fail'
    def dummy(self):
      pass
1926 1927 1928 1929 1930 1931 1932 1933
    invoke = activity_tool.__class__.invoke
    invokeGroup = activity_tool.__class__.invokeGroup
    try:
      activity_tool.__class__.invoke = modifySQLAndFail
      activity_tool.__class__.invokeGroup = modifySQLAndFail
      Organisation.dummy = dummy
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      obj.activate(activity='SQLQueue').dummy()
1934
      self.commit()
1935 1936 1937 1938 1939 1940
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEquals(activity_tool.countMessage(method_id='dummy_activity'), 0)
    finally:
      delattr(Organisation, 'dummy')
      activity_tool.__class__.invoke = invoke
      activity_tool.__class__.invokeGroup = invokeGroup
1941

1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
  def test_88_ProcessingMultipleMessagesMustRevertIndividualMessagesOnError(self, quiet=0, run=run_all_test):
    """
      Check that, on queues which support it, processing a batch of multiple
      messages doesn't cause failed ones to becommited along with succesful
      ones.

      Queues supporting message batch processing:
       - SQLQueue
    """
    if not run: return
    if not quiet:
      message = '\nCheck processing a batch of messages with failures'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
    activity_tool = self.getActivityTool()
    obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    active_obj = obj.activate(activity='SQLQueue')
    def appendToTitle(self, to_append, fail=False):
      self.setTitle(self.getTitle() + to_append)
      if fail:
        raise ValueError, 'This method always fail'
1964 1965 1966 1967 1968 1969 1970
    try:
      Organisation.appendToTitle = appendToTitle
      obj.setTitle('a')
      active_obj.appendToTitle('b')
      active_obj.appendToTitle('c', fail=True)
      active_obj.appendToTitle('d')
      object_id = obj.getId()
1971
      self.commit()
1972 1973 1974 1975
      self.assertEqual(obj.getTitle(), 'a')
      self.assertEqual(activity_tool.countMessage(method_id='appendToTitle'), 3)
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEqual(activity_tool.countMessage(method_id='appendToTitle'), 1)
1976
      self.assertEqual(sorted(obj.getTitle()), ['a', 'b', 'd'])
1977 1978
    finally:
      delattr(Organisation, 'appendToTitle')
1979

1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
  def test_89_RequestIsolationInsideSameTic(self, quiet=0, run=run_all_test):
    """
      Check that request information do not leak from one activity to another
      inside the same TIC invocation.
      This only apply to queues supporting batch processing:
        - SQLQueue
    """
    if not run: return
    if not quiet:
      message = '\nCheck request isolation between messages of the same batch'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
    obj = self.getPortal().organisation_module.newContent(portal_type='Organisation', title='Pending')
    marker_id = 'marker_%i' % (random.randint(1, 10), )
    def putMarkerValue(self, marker_id):
      self.REQUEST.set(marker_id, 1)
    def checkMarkerValue(self, marker_id):
      if self.REQUEST.get(marker_id) is not None:
        self.setTitle('Failed')
      else:
        self.setTitle('Success')
    try:
      Organisation.putMarkerValue = putMarkerValue
      Organisation.checkMarkerValue = checkMarkerValue
      obj.activate(activity='SQLQueue', tag='set_first').putMarkerValue(marker_id=marker_id)
      obj.activate(activity='SQLQueue', after_tag='set_first').checkMarkerValue(marker_id=marker_id)
      self.assertEqual(obj.getTitle(), 'Pending')
      self.tic()
      self.assertEqual(obj.getTitle(), 'Success')
    finally:
      delattr(Organisation, 'putMarkerValue')
      delattr(Organisation, 'checkMarkerValue')

2014 2015 2016 2017 2018 2019 2020 2021
  def TryUserNotificationOnActivityFailure(self, activity):
    self.tic()
    obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    # Use a mutable variable to be able to modify the same instance from
    # monkeypatch method.
    notification_done = []
    from Products.CMFActivity.ActivityTool import Message
2022
    def fake_notifyUser(self, *args, **kw):
2023 2024 2025 2026 2027 2028 2029
      notification_done.append(True)
    original_notifyUser = Message.notifyUser
    def failingMethod(self):
      raise ValueError, 'This method always fail'
    Message.notifyUser = fake_notifyUser
    Organisation.failingMethod = failingMethod
    try:
2030 2031
      # MESSAGE_NOT_EXECUTED
      obj.activate(activity=activity).failingMethod()
2032
      self.commit()
2033 2034 2035
      self.assertEqual(len(notification_done), 0)
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEqual(len(notification_done), 1)
2036 2037 2038
      # MESSAGE_NOT_EXECUTABLE
      obj.getParentValue()._delObject(obj.getId())
      obj.activate(activity=activity).getId()
2039
      self.commit()
2040 2041 2042
      self.assertEqual(len(notification_done), 1)
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEqual(len(notification_done), 2)
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071
    finally:
      Message.notifyUser = original_notifyUser
      delattr(Organisation, 'failingMethod')


  def test_90_userNotificationOnActivityFailureWithSQLDict(self, quiet=0, run=run_all_test):
    """
      Check that a user notification method is called on message when activity
      fails and will not be tried again.
    """
    if not run: return
    if not quiet:
      message = '\nCheck user notification sent on activity final error (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryUserNotificationOnActivityFailure('SQLDict')

  def test_91_userNotificationOnActivityFailureWithSQLQueue(self, quiet=0, run=run_all_test):
    """
      Check that a user notification method is called on message when activity
      fails and will not be tried again.
    """
    if not run: return
    if not quiet:
      message = '\nCheck user notification sent on activity final error (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryUserNotificationOnActivityFailure('SQLQueue')

2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
  def TryUserNotificationRaise(self, activity):
    self.tic()
    obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    from Products.CMFActivity.ActivityTool import Message
    original_notifyUser = Message.notifyUser
    def failingMethod(self, *args, **kw):
      raise ValueError, 'This method always fail'
    Message.notifyUser = failingMethod
    Organisation.failingMethod = failingMethod
    readMessageList = getattr(self.getPortalObject(), '%s_readMessageList'% (activity, ))
    try:
      obj.activate(activity=activity, priority=6).failingMethod()
2085
      self.commit()
2086
      self.flushAllActivities(silent=1, loop_size=100)
2087 2088 2089
      with_processing_len = len(readMessageList(path=None,
                                                to_date=None,
                                                method_id='failingMethod',
2090 2091
                                                include_processing=1,
                                                processing_node=None))
2092 2093 2094
      without_processing_len = len(readMessageList(path=None,
                                                   to_date=None,
                                                   method_id='failingMethod',
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
                                                   include_processing=0,
                                                   processing_node=None))
      self.assertEqual(with_processing_len, 1)
      self.assertEqual(without_processing_len, 1)
    finally:
      Message.notifyUser = original_notifyUser
      delattr(Organisation, 'failingMethod')

  def test_92_userNotificationRaiseWithSQLDict(self, quiet=0, run=run_all_test):
    """
      Check that activities are not left with processing=1 when notifyUser raises.
    """
    if not run: return
    if not quiet:
      message = '\nCheck that activities are not left with processing=1 when notifyUser raises (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryUserNotificationRaise('SQLDict')

  def test_93_userNotificationRaiseWithSQLQueue(self, quiet=0, run=run_all_test):
    """
      Check that activities are not left with processing=1 when notifyUser raises.
    """
    if not run: return
    if not quiet:
      message = '\nCheck that activities are not left with processing=1 when notifyUser raises (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryUserNotificationRaise('SQLQueue')
    
  def test_94_ActivityToolCommitFailureDoesNotCommitCMFActivitySQLConnectionSQLDict(self, quiet=0, run=run_all_test):
    """
      Check that CMFActivity SQL connection is rollback if transaction commit raises.
    """
    if not run: return
    if not quiet:
      message = '\nCheck that activity modifications via CMFActivity connection are rolled back on commit error (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
    activity_tool = self.getActivityTool()
2136
    def modifySQL(self, object_list):
2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153
      # Only create the dummy activity if none is present: we would just
      # generate missleading errors (duplicate uid).
      if activity_tool.countMessage(method_id='dummy_activity') == 0:
        # Add a dumy activity which will not be executed
        # Modified table does not matter
        method_id = 'dummy_activity'
        path = '/'.join(self.getPhysicalPath())
        message = Message(self, None, {}, method_id, (), {})
        pickled_message = pickle.dumps(message)
        self.SQLDict_writeMessageList(
          uid_list=[0], # This uid is never automaticaly assigned (starts at 1)
          date_list=[DateTime().Date()],
          path_list=[path],
          method_id_list=[method_id],
          message_list=[pickled_message],
          priority_list=[1],
          processing_node_list=[-2],
2154
          group_method_id_list=['\0'],
2155
          tag_list=[''],
2156
          order_validation_text_list=[''],
2157
          )
2158 2159
      transaction.get().__class__.commit = fake_commit
    commit = transaction.get().__class__.commit
2160
    def fake_commit(*args, **kw):
2161
      transaction.get().__class__.commit = commit
2162 2163 2164 2165 2166 2167 2168 2169 2170
      raise KeyError, 'always fail'
    try: 
      Organisation.modifySQL = modifySQL
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      group_method_id = '%s/modifySQL' % (obj.getPath(), )
      obj2 = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      self.tic()
      obj.activate(activity='SQLDict', group_method_id=group_method_id).modifySQL()
      obj2.activate(activity='SQLDict', group_method_id=group_method_id).modifySQL()
2171
      self.commit()
2172 2173 2174
      try:
        self.flushAllActivities(silent=1, loop_size=100)
      finally:
2175
        transaction.get().__class__.commit = commit
2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
      self.assertEquals(activity_tool.countMessage(method_id='dummy_activity'), 0)
    finally:
      delattr(Organisation, 'modifySQL')
  
  def test_95_ActivityToolCommitFailureDoesNotCommitCMFActivitySQLConnectionSQLQueue(self, quiet=0, run=run_all_test):
    """
      Check that CMFActivity SQL connection is rollback if activity_tool.invoke raises.
    """
    if not run: return
    if not quiet:
      message = '\nCheck that activity modifications via CMFActivity connection are rolled back on commit error (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.tic()
    activity_tool = self.getActivityTool()
    def modifySQL(self, *args, **kw):
      # Only create the dummy activity if none is present: we would just
      # generate missleading errors (duplicate uid).
      if activity_tool.countMessage(method_id='dummy_activity') == 0:
        # Add a dumy activity which will not be executed
        # Modified table does not matter
        method_id = 'dummy_activity'
        path = '/'.join(self.getPhysicalPath())
        message = Message(self, None, {}, method_id, (), {})
        pickled_message = pickle.dumps(message)
        self.SQLDict_writeMessageList(
          uid_list=[0], # This uid is never automaticaly assigned (starts at 1)
          date_list=[DateTime().Date()],
          path_list=[path],
          method_id_list=[method_id],
          message_list=[pickled_message],
          priority_list=[1],
          processing_node_list=[-2],
2209
          group_method_id_list=['\0'],
2210
          tag_list=[''],
2211
          order_validation_text_list=[''],
2212
         )
2213 2214
      transaction.get().__class__.commit = fake_commit
    commit = transaction.get().__class__.commit
2215
    def fake_commit(self, *args, **kw):
2216
      transaction.get().__class__.commit = commit
2217 2218 2219 2220 2221 2222
      raise KeyError, 'always fail'
    try:
      Organisation.modifySQL = modifySQL
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      self.tic()
      obj.activate(activity='SQLQueue').modifySQL()
2223
      self.commit()
2224 2225 2226
      try:
        self.flushAllActivities(silent=1, loop_size=100)
      finally:
2227
        transaction.get().__class__.commit = commit
2228 2229 2230
      self.assertEquals(activity_tool.countMessage(method_id='dummy_activity'), 0)
    finally:
      delattr(Organisation, 'modifySQL')
2231

2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246
  def TryActivityRaiseInCommitDoesNotStallActivityConection(self, activity):
    """
      Check that an activity which commit raises (as would a regular conflict
      error be raised in tpc_vote) does not cause activity connection to
      stall.
    """
    self.tic()
    activity_tool = self.getActivityTool()
    from Shared.DC.ZRDB.TM import TM
    try:
      Organisation.registerFailingTransactionManager = registerFailingTransactionManager
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      self.tic()
      now = DateTime()
      obj.activate(activity=activity).registerFailingTransactionManager()
2247
      self.commit()
2248
      self.flushAllActivities(silent=1, loop_size=100)
2249
      self.commit()
2250 2251 2252 2253 2254 2255 2256
      # Check that cmf_activity SQL connection still works
      connection_da_pool = self.getPortalObject().cmf_activity_sql_connection()
      import thread
      connection_da = connection_da_pool._db_pool[thread.get_ident()]
      self.assertFalse(connection_da._registered)
      connection_da_pool.query('select 1')
      self.assertTrue(connection_da._registered)
2257
      self.commit()
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
      self.assertFalse(connection_da._registered)
    finally:
      delattr(Organisation, 'registerFailingTransactionManager')

  def test_96_ActivityRaiseInCommitDoesNotStallActivityConectionSQLDict(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that raising in commit does not stall cmf activity SQL connection (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivityRaiseInCommitDoesNotStallActivityConection('SQLDict')

  def test_97_ActivityRaiseInCommitDoesNotStallActivityConectionSQLQueue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that raising in commit does not stall cmf activity SQL connection (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivityRaiseInCommitDoesNotStallActivityConection('SQLQueue')

2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
  def TryActivityRaiseInCommitDoesNotLooseMessages(self, activity):
    """
    """
    self.tic()
    activity_tool = self.getActivityTool()
    try:
      Organisation.registerFailingTransactionManager = registerFailingTransactionManager
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      self.tic()
      now = DateTime()
      obj.activate(activity=activity).registerFailingTransactionManager()
2289
      self.commit()
2290
      self.flushAllActivities(silent=1, loop_size=100)
2291
      self.commit()
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
      self.assertEquals(activity_tool.countMessage(method_id='registerFailingTransactionManager'), 1)
    finally:
      delattr(Organisation, 'registerFailingTransactionManager')

  def test_98_ActivityRaiseInCommitDoesNotLooseMessagesSQLDict(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that raising in commit does not loose messages (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivityRaiseInCommitDoesNotLooseMessages('SQLDict')

  def test_99_ActivityRaiseInCommitDoesNotLooseMessagesSQLQueue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that raising in commit does not loose messages (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryActivityRaiseInCommitDoesNotLooseMessages('SQLQueue')
2311

2312 2313 2314 2315 2316 2317 2318 2319 2320 2321
  def TryChangeSkinInActivity(self, activity):
    self.tic()
    activity_tool = self.getActivityTool()
    def changeSkinToNone(self):
      self.getPortalObject().changeSkin(None)
    Organisation.changeSkinToNone = changeSkinToNone
    try:
      organisation = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      self.tic()
      organisation.activate(activity=activity).changeSkinToNone()
2322
      self.commit()
2323 2324 2325 2326 2327 2328
      self.assertEquals(len(activity_tool.getMessageList()), 1)
      self.flushAllActivities(silent=1, loop_size=100)
      self.assertEquals(len(activity_tool.getMessageList()), 0)
    finally:
      delattr(Organisation, 'changeSkinToNone')

Vincent Pelletier's avatar
Vincent Pelletier committed
2329
  def test_100_TryChangeSkinInActivitySQLDict(self, quiet=0, run=run_all_test):
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
    if not run: return
    if not quiet:
      message = '\nTry Change Skin In Activity (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryChangeSkinInActivity('SQLDict')

  def test_101_TryChangeSkinInActivitySQLQueue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nTry ChangeSkin In Activity (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryChangeSkinInActivity('SQLQueue')
2344

2345 2346 2347 2348 2349
  def test_102_1_CheckSQLDictDoesNotDeleteSimilaritiesBeforeExecution(self, quiet=0, run=run_all_test):
    """
      Test that SQLDict does not delete similar messages which have the same
      method_id and path but a different tag before execution.
    """
2350 2351
    if not run: return
    if not quiet:
2352
      message = '\nCheck similarities are not deleted before execution of original message (SQLDict)'
2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    organisation = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    activity_tool = self.getActivityTool()
    check_result_dict = {}
    def checkActivityCount(self, other_tag):
      if len(check_result_dict) == 0:
        check_result_dict['done'] = activity_tool.countMessage(tag=other_tag)
    try:
      Organisation.checkActivityCount = checkActivityCount
2364
      # Adds two similar but not the same activities.
2365 2366
      organisation.activate(activity='SQLDict', tag='a').checkActivityCount(other_tag='b')
      organisation.activate(activity='SQLDict', tag='b').checkActivityCount(other_tag='a')
2367
      self.commit()
2368
      self.assertEqual(len(activity_tool.getMessageList()), 2)
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398
      activity_tool.distribute()
      # after distribute, similarities are still there.
      self.assertEqual(len(activity_tool.getMessageList()), 2)
      self.tic()
      self.assertEqual(len(activity_tool.getMessageList()), 0)
      self.assertEqual(len(check_result_dict), 1)
      self.assertEqual(check_result_dict['done'], 1)
    finally:
      delattr(Organisation, 'checkActivityCount')

  def test_102_2_CheckSQLDictDeleteDuplicatesBeforeExecution(self, quiet=0, run=run_all_test):
    """
      Test that SQLDict delete the same messages before execution if messages
      has the same method_id and path and tag.
    """
    if not run: return
    if not quiet:
      message = '\nCheck duplicates are deleted before execution of original message (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    organisation = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    activity_tool = self.getActivityTool()
    check_result_dict = {}
    def checkActivityCount(self, other_tag):
      if len(check_result_dict) == 0:
        check_result_dict['done'] = activity_tool.countMessage(tag=other_tag)
    try:
      Organisation.checkActivityCount = checkActivityCount
      # Adds two same activities.
2399
      organisation.activate(activity='SQLDict', tag='a', priority=2).checkActivityCount(other_tag='a')
2400
      self.commit()
2401 2402
      uid1, = [x.uid for x in activity_tool.getMessageList()]
      organisation.activate(activity='SQLDict', tag='a', priority=1).checkActivityCount(other_tag='a')
2403
      self.commit()
2404 2405 2406
      self.assertEqual(len(activity_tool.getMessageList()), 2)
      activity_tool.distribute()
      # After distribute, duplicate is deleted.
2407 2408
      uid2, = [x.uid for x in activity_tool.getMessageList()]
      self.assertNotEqual(uid1, uid2)
2409 2410 2411 2412 2413 2414 2415
      self.tic()
      self.assertEqual(len(activity_tool.getMessageList()), 0)
      self.assertEqual(len(check_result_dict), 1)
      self.assertEqual(check_result_dict['done'], 1)
    finally:
      delattr(Organisation, 'checkActivityCount')

2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428
  def test_102_3_CheckSQLDictDistributeWithSerializationTagAndGroupMethodId(
      self, quiet=0):
    """
      Distribuation was at some point buggy with this scenario when there was
      activate with the same serialization_tag and one time with a group_method
      id and one without group_method_id :
        foo.activate(serialization_tag='a', group_method_id='x').getTitle()
        foo.activate(serialization_tag='a').getId()
    """
    organisation = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    activity_tool = self.getActivityTool()
    organisation.activate(serialization_tag='a').getId()
2429
    self.commit()
2430 2431
    organisation.activate(serialization_tag='a',
              group_method_id='portal_catalog/catalogObjectList').getTitle()
2432
    self.commit()
2433 2434 2435 2436 2437 2438 2439
    self.assertEqual(len(activity_tool.getMessageList()), 2)
    activity_tool.distribute()
    # After distribute, there is no deletion because it is different method
    self.assertEqual(len(activity_tool.getMessageList()), 2)
    self.tic()
    self.assertEqual(len(activity_tool.getMessageList()), 0)

2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
  def test_103_interQueuePriorities(self, quiet=0, run=run_all_test):
    """
      Important note: there is no way to really reliably check that this
      feature is correctly implemented, as activity execution order is
      non-deterministic.
      The best which can be done is to check that under certain circumstances
      the activity exeicution order match expectations.
    """
    if not run: return
    if not quiet:
      message = '\nCheck inter-queue priorities'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    organisation = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    activity_tool = self.getActivityTool()
    check_result_dict = {}
    def runAndCheck():
      check_result_dict.clear()
2459
      self.commit()
2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490
      self.assertEqual(len(check_result_dict), 0)
      self.tic()
      self.assertEqual(len(check_result_dict), 2)
      self.assertTrue(check_result_dict['before_ran'])
      self.assertTrue(check_result_dict['after_ran'])
    def mustRunBefore(self):
      check_result_dict['before_ran'] = 'after_ran' not in check_result_dict
    def mustRunAfter(self):
      check_result_dict['after_ran'] = 'before_ran' in check_result_dict
    Organisation.mustRunBefore = mustRunBefore
    Organisation.mustRunAfter = mustRunAfter
    try:
      # Check that ordering looks good (SQLQueue first)
      organisation.activate(activity='SQLQueue', priority=1).mustRunBefore()
      organisation.activate(activity='SQLDict',  priority=2).mustRunAfter()
      runAndCheck()
      # Check that ordering looks good (SQLDict first)
      organisation.activate(activity='SQLDict',  priority=1).mustRunBefore()
      organisation.activate(activity='SQLQueue', priority=2).mustRunAfter()
      runAndCheck()
      # Check that tag takes precedence over priority (SQLQueue first by priority)
      organisation.activate(activity='SQLQueue', priority=1, after_tag='a').mustRunAfter()
      organisation.activate(activity='SQLDict',  priority=2, tag='a').mustRunBefore()
      runAndCheck()
      # Check that tag takes precedence over priority (SQLDict first by priority)
      organisation.activate(activity='SQLDict',  priority=1, after_tag='a').mustRunAfter()
      organisation.activate(activity='SQLQueue', priority=2, tag='a').mustRunBefore()
      runAndCheck()
    finally:
      delattr(Organisation, 'mustRunBefore')
      delattr(Organisation, 'mustRunAfter')
2491 2492

  def CheckActivityRuntimeEnvironment(self, activity):
2493 2494
    document = self.portal.organisation_module
    activity_result = []
2495
    def extractActivityRuntimeEnvironment(self):
2496 2497
      activity_result.append(self.getActivityRuntimeEnvironment())
    document.__class__.doSomething = extractActivityRuntimeEnvironment
2498
    try:
2499
      document.activate(activity=activity).doSomething()
2500
      self.commit()
2501 2502
      # Check that getActivityRuntimeEnvironment raises outside of activities
      self.assertRaises(KeyError, document.getActivityRuntimeEnvironment)
2503
      # Check Runtime isolation
2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516
      self.tic()
      # Check that it still raises outside of activities
      self.assertRaises(KeyError, document.getActivityRuntimeEnvironment)
      # Check activity runtime environment instance
      env = activity_result.pop()
      self.assertFalse(activity_result)
      message = env._message
      self.assertEqual(message.line.priority, 1)
      self.assertEqual(message.object_path, document.getPhysicalPath())
      self.assertTrue(message.conflict_retry) # default value
      env.edit(max_retry=0, conflict_retry=False)
      self.assertFalse(message.conflict_retry) # edited value
      self.assertRaises(AttributeError, env.edit, foo='bar')
2517
    finally:
2518
      del document.__class__.doSomething
2519

Vincent Pelletier's avatar
Vincent Pelletier committed
2520
  def test_104_activityRuntimeEnvironmentSQLDict(self, quiet=0, run=run_all_test):
2521 2522 2523 2524 2525 2526 2527
    if not run: return
    if not quiet:
      message = '\nCheck ActivityRuntimeEnvironment (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckActivityRuntimeEnvironment('SQLDict')

Vincent Pelletier's avatar
Vincent Pelletier committed
2528
  def test_105_activityRuntimeEnvironmentSQLQueue(self, quiet=0, run=run_all_test):
2529 2530 2531 2532 2533 2534 2535
    if not run: return
    if not quiet:
      message = '\nCheck ActivityRuntimeEnvironment (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckActivityRuntimeEnvironment('SQLQueue')

2536 2537 2538 2539 2540 2541 2542 2543 2544
  def CheckSerializationTag(self, activity):
    organisation = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    activity_tool = self.getActivityTool()
    result = activity_tool.getMessageList()
    self.assertEqual(len(result), 0)
    # First scenario: activate, distribute, activate, distribute
    # Create first activity and distribute: it must be distributed
    organisation.activate(activity=activity, serialization_tag='1').getTitle()
2545
    self.commit()
2546 2547 2548 2549 2550 2551 2552
    result = activity_tool.getMessageList()
    self.assertEqual(len(result), 1)
    activity_tool.distribute()
    result = activity_tool.getMessageList()
    self.assertEqual(len([x for x in result if x.processing_node == 0]), 1)
    # Create second activity and distribute: it must *NOT* be distributed
    organisation.activate(activity=activity, serialization_tag='1').getTitle()
2553
    self.commit()
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
    result = activity_tool.getMessageList()
    self.assertEqual(len(result), 2)
    activity_tool.distribute()
    result = activity_tool.getMessageList()
    self.assertEqual(len([x for x in result if x.processing_node == 0]), 1) # Distributed message list len is still 1
    self.tic()
    result = activity_tool.getMessageList()
    self.assertEqual(len(result), 0)
    # Second scenario: activate, activate, distribute
    # Both messages must be distributed (this is different from regular tags)
2564
    organisation.activate(activity=activity, serialization_tag='1', priority=2).getTitle()
2565
    # Use a different method just so that SQLDict doesn't merge both activities prior to insertion.
2566
    organisation.activate(activity=activity, serialization_tag='1', priority=1).getId()
2567
    self.commit()
2568 2569 2570 2571
    result = activity_tool.getMessageList()
    self.assertEqual(len(result), 2)
    activity_tool.distribute()
    result = activity_tool.getMessageList()
2572 2573 2574 2575 2576 2577
    # at most 1 activity for a given serialization tag can be validated
    message, = [x for x in result if x.processing_node == 0]
    self.assertEqual(message.method_id, 'getId')
    # the other one is still waiting for validation
    message, = [x for x in result if x.processing_node == -1]
    self.assertEqual(message.method_id, 'getTitle')
2578 2579
    self.tic()
    result = activity_tool.getMessageList()
2580
    self.assertEqual(len(result), 0)
2581 2582 2583 2584 2585
    # Check that giving a None value to serialization_tag does not confuse
    # CMFActivity
    organisation.activate(activity=activity, serialization_tag=None).getTitle()
    self.tic()
    self.assertEqual(len(activity_tool.getMessageList()), 0)
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602

  def test_106_checkSerializationTagSQLDict(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck serialization tag (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckSerializationTag('SQLDict')

  def test_107_checkSerializationTagSQLQueue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck serialization tag (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckSerializationTag('SQLQueue')

2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640
  def test_108_testAbsoluteUrl(self):
    # Tests that absolute_url works in activities. The URL generation is based
    # on REQUEST information when the method was activated.
    request = self.portal.REQUEST

    request.setServerURL('http', 'test.erp5.org', '9080')
    request.other['PARENTS'] = [self.portal.organisation_module]
    request.setVirtualRoot('virtual_root')

    calls = []
    def checkAbsoluteUrl(self):
      calls.append(self.absolute_url())
    Organisation.checkAbsoluteUrl = checkAbsoluteUrl

    try:
      o = self.portal.organisation_module.newContent(
                    portal_type='Organisation', id='test_obj')
      self.assertEquals(o.absolute_url(),
          'http://test.erp5.org:9080/virtual_root/test_obj')
      o.activate().checkAbsoluteUrl()
      
      # Reset server URL and virtual root before executing messages.
      # This simulates the case of activities beeing executed with different
      # REQUEST, such as TimerServer.
      request.setServerURL('https', 'anotherhost.erp5.org', '443')
      request.other['PARENTS'] = [self.app]
      request.setVirtualRoot('')
      # obviously, the object url is different
      self.assertEquals(o.absolute_url(),
          'https://anotherhost.erp5.org/%s/organisation_module/test_obj'
           % self.portal.getId())

      # but activities are executed using the previous request information
      self.flushAllActivities(loop_size=1000)
      self.assertEquals(calls, ['http://test.erp5.org:9080/virtual_root/test_obj'])
    finally:
      delattr(Organisation, 'checkAbsoluteUrl')

2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652
  def CheckMissingActivityContextObject(self, activity):
    """
      Check that a message whose context has ben deleted goes to -3
      processing_node.
      This must happen on first message execution, without any delay.
    """
    readMessageList = getattr(self.getPortalObject(), '%s_readMessageList' % (activity, ))
    activity_tool = self.getActivityTool()
    container = self.getPortal().organisation_module
    organisation = container.newContent(portal_type='Organisation')
    self.tic()
    organisation.activate(activity=activity).getTitle()
2653
    self.commit()
2654 2655 2656 2657 2658 2659
    self.assertEqual(len(activity_tool.getMessageList()), 1)
    # Here, we delete the subobject using most low-level method, to avoid
    # pending activity to be removed.
    organisation_id = organisation.id
    container._delOb(organisation_id)
    del organisation # Avoid keeping a reference to a deleted object.
2660
    self.commit()
2661 2662 2663 2664
    self.assertEqual(getattr(container, organisation_id, None), None)
    self.assertEqual(len(activity_tool.getMessageList()), 1)
    activity_tool.distribute()
    self.assertEquals(len(readMessageList(processing_node=-3,
2665 2666
                            include_processing=1, path=None, method_id=None,
                            to_date=None)), 0)
2667 2668
    activity_tool.tic()
    self.assertEquals(len(readMessageList(processing_node=-3,
2669 2670
                            include_processing=1, path=None, method_id=None,
                            to_date=None)), 1)
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709

  def test_109_checkMissingActivityContextObjectSQLDict(self, quiet=0,
      run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck missing activity context object (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckMissingActivityContextObject('SQLDict')

  def test_110_checkMissingActivityContextObjectSQLQueue(self, quiet=0,
      run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck missing activity context object (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckMissingActivityContextObject('SQLQueue')

  def test_111_checkMissingActivityContextObjectSQLDict(self, quiet=0,
      run=run_all_test):
    """
      This is similar to tst 108, but here the object will be missing for an
      activity with a group_method_id.
    """
    if not run: return
    if not quiet:
      message = '\nCheck missing activity context object with ' \
                'group_method_id (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    readMessageList = self.getPortalObject().SQLDict_readMessageList
    activity_tool = self.getActivityTool()
    container = self.getPortalObject().organisation_module
    organisation = container.newContent(portal_type='Organisation')
    organisation_2 = container.newContent(portal_type='Organisation')
    self.tic()
    organisation.reindexObject()
    organisation_2.reindexObject()
2710
    self.commit()
2711 2712 2713 2714 2715 2716
    self.assertEqual(len(activity_tool.getMessageList()), 2)
    # Here, we delete the subobject using most low-level method, to avoid
    # pending activity to be removed.
    organisation_id = organisation.id
    container._delOb(organisation_id)
    del organisation # Avoid keeping a reference to a deleted object.
2717
    self.commit()
2718 2719 2720 2721
    self.assertEqual(getattr(container, organisation_id, None), None)
    self.assertEqual(len(activity_tool.getMessageList()), 2)
    activity_tool.distribute()
    self.assertEquals(len(readMessageList(processing_node=-3,
2722 2723
                            include_processing=1, path=None, method_id=None,
                            to_date=None)), 0)
2724 2725
    activity_tool.tic()
    self.assertEquals(len(readMessageList(processing_node=-3,
2726 2727
                            include_processing=1, path=None, method_id=None,
                            to_date=None)), 1)
2728 2729
    # The message excuted on "organisation_2" must have succeeded.
    self.assertEqual(len(activity_tool.getMessageList()), 1)
2730

2731 2732 2733 2734 2735
  def CheckLocalizerWorks(self, activity):
    FROM_STRING = 'Foo'
    TO_STRING = 'Bar'
    LANGUAGE = 'xx'
    def translationTest(context):
2736
      from Products.ERP5Type.Message import Message
2737
      context.setTitle(context.Base_translateString(FROM_STRING))
2738
      context.setDescription(str(Message('erp5_ui', FROM_STRING)))
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750
    portal = self.getPortalObject()
    portal.Localizer.erp5_ui.manage_addLanguage(LANGUAGE)
    # Add FROM_STRING to the message catalog
    portal.Localizer.erp5_ui.gettext(FROM_STRING)
    # ...and translate it.
    portal.Localizer.erp5_ui.message_edit(message=FROM_STRING,
      language=LANGUAGE, translation=TO_STRING, note='')
    organisation = portal.organisation_module.newContent(
      portal_type='Organisation')
    self.tic()
    Organisation.translationTest = translationTest
    try:
2751 2752 2753
      REQUEST = organisation.REQUEST
      # Simulate what a browser would have sent to Zope
      REQUEST.environ['HTTP_ACCEPT_LANGUAGE'] = LANGUAGE
2754
      organisation.activate(activity=activity).translationTest()
2755
      self.commit()
2756 2757 2758
      # Remove request parameter to check that it was saved at activate call
      # and restored at message execution.
      del REQUEST.environ['HTTP_ACCEPT_LANGUAGE']
2759 2760 2761 2762
      self.tic()
    finally:
      delattr(Organisation, 'translationTest')
    self.assertEqual(TO_STRING, organisation.getTitle())
2763
    self.assertEqual(TO_STRING, organisation.getDescription())
2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780

  def test_112_checkLocalizerWorksSQLQueue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck Localizer works (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckLocalizerWorks('SQLQueue')

  def test_113_checkLocalizerWorksSQLDict(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck Localizer works (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckLocalizerWorks('SQLDict')

2781 2782 2783 2784 2785 2786 2787 2788
  def testMessageContainsFailureTraceback(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck message contains failure traceback'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    portal = self.getPortalObject()
    activity_tool = self.getActivityTool()
2789
    def checkMessage(message, exception_type):
2790
      self.assertNotEqual(message.getExecutionState(), 1) # 1 == MESSAGE_EXECUTED
2791
      self.assertEqual(message.exc_type, exception_type)
2792 2793 2794 2795 2796 2797
      self.assertNotEqual(message.traceback, None)
    # With Message.__call__
    # 1: activity context does not exist when activity is executed
    organisation = portal.organisation_module.newContent(portal_type='Organisation')
    self.tic()
    organisation.activate().getTitle() # This generates the mssage we want to test.
2798
    self.commit()
2799 2800 2801 2802 2803
    message_list = activity_tool.getMessageList()
    self.assertEqual(len(message_list), 1)
    message = message_list[0]
    portal.organisation_module._delOb(organisation.id)
    message(activity_tool)
2804
    checkMessage(message, KeyError)
2805 2806 2807
    activity_tool.manageCancel(message.object_path, message.method_id)
    # 2: activity method does not exist when activity is executed
    portal.organisation_module.activate().this_method_does_not_exist()
2808
    self.commit()
2809 2810 2811 2812
    message_list = activity_tool.getMessageList()
    self.assertEqual(len(message_list), 1)
    message = message_list[0]
    message(activity_tool)
2813
    checkMessage(message, AttributeError)
2814 2815 2816 2817 2818 2819 2820
    activity_tool.manageCancel(message.object_path, message.method_id)

    # With ActivityTool.invokeGroup
    # 1: activity context does not exist when activity is executed
    organisation = portal.organisation_module.newContent(portal_type='Organisation')
    self.tic()
    organisation.activate().getTitle() # This generates the mssage we want to test.
2821
    self.commit()
2822 2823 2824 2825
    message_list = activity_tool.getMessageList()
    self.assertEqual(len(message_list), 1)
    message = message_list[0]
    portal.organisation_module._delOb(organisation.id)
2826
    activity_tool.invokeGroup('getTitle', [message], 'SQLDict', True)
2827
    checkMessage(message, KeyError)
2828 2829 2830
    activity_tool.manageCancel(message.object_path, message.method_id)
    # 2: activity method does not exist when activity is executed
    portal.organisation_module.activate().this_method_does_not_exist()
2831
    self.commit()
2832 2833 2834
    message_list = activity_tool.getMessageList()
    self.assertEqual(len(message_list), 1)
    message = message_list[0]
2835 2836
    activity_tool.invokeGroup('this_method_does_not_exist',
                              [message], 'SQLDict', True)
2837
    checkMessage(message, KeyError)
2838 2839 2840 2841 2842
    activity_tool.manageCancel(message.object_path, message.method_id)

    # Unadressed error paths (in both cases):
    #  3: activity commit raises
    #  4: activity raises
2843

2844
  def test_114_checkSQLQueueActivitySucceedsAfterActivityChangingSkin(self,
2845
    quiet=0, run=run_all_test):
2846 2847 2848 2849 2850
    if not run: return
    if not quiet:
      message = '\nCheck SQLQueue activity succeeds after an activity changing skin selection'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874
    portal = self.getPortalObject()
    activity_tool = self.getActivityTool()
    # Check that a reference script can be reached
    script_id = 'ERP5Site_reindexAll'
    self.assertTrue(getattr(portal, script_id, None) is not None)
    # Create a new skin selection
    skin_selection_name = 'test_114'
    portal.portal_skins.manage_skinLayers(add_skin=1, skinpath=[''], skinname=skin_selection_name)
    # Create a dummy document
    organisation = portal.organisation_module.newContent(portal_type='Organisation')
    self.tic()
    # Set custom methods to call as activities.
    def first(context):
      context.changeSkin(skin_selection_name)
      if getattr(context, script_id, None) is not None:
        raise Exception, '%s is not supposed to be found here.' % (script_id, )
    def second(context):
      # If the wrong skin is selected this will raise.
      getattr(context, script_id)
    Organisation.firstTest = first
    Organisation.secondTest = second
    try:
      organisation.activate(tag='foo', activity='SQLQueue').firstTest()
      organisation.activate(after_tag='foo', activity='SQLQueue').secondTest()
2875
      self.commit()
2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
      import gc
      gc.disable()
      self.tic()
      gc.enable()
      # Forcibly restore skin selection, otherwise getMessageList would only
      # emit a log when retrieving the ZSQLMethod.
      portal.changeSkin(None)
      self.assertEquals(len(activity_tool.getMessageList()), 0)
    finally:
      delattr(Organisation, 'firstTest')
      delattr(Organisation, 'secondTest')

2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907
  def test_115_checkProcessShutdown(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that no activity is executed after process_shutdown has been called'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    # Thread execution plan for this test:
    # main                             ActivityThread           ProcessShutdownThread
    # start ActivityThread             None                     None
    # wait for rendez_vous_lock        (run)                    None
    # wait for rendez_vous_lock        release rendez_vous_lock None
    # start ProcessShutdownThread      wait for activity_lock   None
    # release activity_lock            wait for activity_lock   internal wait
    # wait for activity_thread         (finish)                 internal wait
    # wait for process_shutdown_thread None                     (finish)
    # 
    # This test only checks that:
    # - activity tool can exit between 2 processable activity batches
    # - activity tool won't process activities after process_shutdown was called
    # - process_shutdown returns before Activity.tic()
Vincent Pelletier's avatar
Vincent Pelletier committed
2908
    #   This is not perfect though, since it would require to have access to
2909 2910 2911 2912 2913 2914
    #   the waiting queue of CMFActivity's internal lock (is_running_lock) to
    #   make sure that it's what is preventing process_shutdown from returning.
    portal = self.getPortalObject()
    activity_tool = self.getActivityTool()
    organisation = portal.organisation_module.newContent(portal_type='Organisation')
    self.tic()
2915 2916
    activity_event = threading.Event()
    rendez_vous_event = threading.Event()
2917 2918
    def waitingActivity(context):
      # Inform test that we arrived at rendez-vous.
2919 2920 2921
      rendez_vous_event.set()
      # When this event is available, it means test has called process_shutdown.
      activity_event.wait()
2922 2923
    from Products.CMFActivity.Activity.SQLDict import SQLDict
    original_dequeue = SQLDict.dequeueMessage
2924
    queue_tic_test_dict = {}
2925
    def dequeueMessage(self, activity_tool, processing_node):
2926
      # This is a one-shot method, revert after execution
2927 2928 2929
      SQLDict.dequeueMessage = original_dequeue
      result = self.dequeueMessage(activity_tool, processing_node)
      queue_tic_test_dict['isAlive'] = process_shutdown_thread.isAlive()
2930
      return result
2931
    SQLDict.dequeueMessage = dequeueMessage
2932 2933
    Organisation.waitingActivity = waitingActivity
    try:
Vincent Pelletier's avatar
Vincent Pelletier committed
2934
      # Use SQLDict with no group method so that both activities won't be
2935 2936
      # executed in the same batch, letting activity tool a chance to check
      # if execution should stop processing activities.
2937 2938
      organisation.activate(activity='SQLDict', tag='foo').waitingActivity()
      organisation.activate(activity='SQLDict', after_tag='foo').getTitle()
2939
      self.commit()
2940 2941
      self.assertEqual(len(activity_tool.getMessageList()), 2)
      activity_tool.distribute()
2942
      self.commit()
2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966

      # Start a tic in another thread, so they can meet at rendez-vous.
      class ActivityThread(threading.Thread):
        def run(self):
          # Call changeskin, since skin selection depend on thread id, and we
          # are in a new thread.
          activity_tool.changeSkin(None)
          activity_tool.tic()
      activity_thread = ActivityThread()
      # Do not try to outlive main thread.
      activity_thread.setDaemon(True)
      # Call process_shutdown in yet another thread because it will wait for
      # running activity to complete before returning, and we need to unlock
      # activity *after* calling process_shutdown to make sure the next
      # activity won't be executed.
      class ProcessShutdownThread(threading.Thread):
        def run(self):
          activity_tool.process_shutdown(3, 0)
      process_shutdown_thread = ProcessShutdownThread()
      # Do not try to outlive main thread.
      process_shutdown_thread.setDaemon(True)

      activity_thread.start()
      # Wait at rendez-vous for activity to arrive.
2967
      rendez_vous_event.wait()
2968 2969 2970 2971
      # Initiate shutdown
      process_shutdown_thread.start()
      try:
        # Let waiting activity finish and wait for thread exit
2972
        activity_event.set()
2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
        activity_thread.join()
        process_shutdown_thread.join()
        # Check that there is still one activity pending
        message_list = activity_tool.getMessageList()
        self.assertEqual(len(message_list), 1)
        self.assertEqual(message_list[0].method_id, 'getTitle')
        # Check that process_shutdown_thread was still runing when Queue_tic returned.
        self.assertTrue(queue_tic_test_dict.get('isAlive'), repr(queue_tic_test_dict))
        # Call tic in foreground. This must not lead to activity execution.
        activity_tool.tic()
        self.assertEqual(len(activity_tool.getMessageList()), 1)
      finally:
        # Put activity tool back in a working state
        from Products.CMFActivity.ActivityTool import cancelProcessShutdown
        try:
          cancelProcessShutdown()
2989
        except StandardException:
2990 2991 2992 2993 2994 2995
          # If something failed in process_shutdown, shutdown lock might not
          # be taken in CMFActivity, leading to a new esception here hiding
          # test error.
          pass
    finally:
      delattr(Organisation, 'waitingActivity')
2996
      SQLDict.dequeueMessage = original_dequeue
2997 2998

  def test_hasActivity(self):
2999 3000
    active_object = self.portal.organisation_module.newContent(
                                            portal_type='Organisation')
3001
    active_process = self.portal.portal_activities.newActiveProcess()
3002
    self.tic()
3003

3004
    self.assertFalse(active_object.hasActivity())
3005 3006 3007 3008 3009
    self.assertFalse(active_process.hasActivity())

    def test(obj, **kw):
      for activity in ('SQLDict', 'SQLQueue'):
        active_object.activate(activity=activity, **kw).getTitle()
3010
        self.commit()
3011 3012 3013 3014 3015 3016 3017
        self.assertTrue(obj.hasActivity(), activity)
        self.tic()
        self.assertFalse(obj.hasActivity(), activity)

    test(active_object)
    test(active_process, active_process=active_process)
    test(active_process, active_process=active_process.getPath())
3018

3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037
  def test_active_object_hasActivity_does_not_catch_exceptions(self):
    """
    Some time ago, hasActivity was doing a silent try/except, and this was
    a possible disaster for some projects. Here we make sure that if the 
    SQL request fails, then the exception is not ignored
    """
    active_object = self.portal.organisation_module.newContent(
                                            portal_type='Organisation')
    self.tic()
    self.assertFalse(active_object.hasActivity())

    # Monkey patch to induce any error artificially in the sql connection.
    def query(self, query_string,*args, **kw):
      raise ValueError

    from Products.ZMySQLDA.db import DB
    DB.original_query = DB.query
    try:
      active_object.activate().getTitle()
3038
      self.commit()
3039 3040 3041 3042 3043 3044 3045 3046 3047
      self.assertTrue(active_object.hasActivity())
      # Make the sql request not working
      DB.original_query = DB.query
      DB.query = query
      # Make sure then that hasActivity fails
      self.assertRaises(ValueError, active_object.hasActivity)
    finally:
      DB.query = DB.original_query
      del DB.original_query
3048

3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099
  def test_MAX_MESSAGE_LIST_SIZE_SQLQueue(self):
    from Products.CMFActivity.Activity import SQLQueue
    old_MAX_MESSAGE_LIST_SIZE = SQLQueue.MAX_MESSAGE_LIST_SIZE
    SQLQueue.MAX_MESSAGE_LIST_SIZE = 3

    try:
      global call_count
      call_count = 0
      def dummy_counter(self):
        global call_count
        call_count += 1

      Organisation.dummy_counter = dummy_counter
      o = self.portal.organisation_module.newContent(portal_type='Organisation',)

      for i in range(10):
        o.activate(activity='SQLQueue').dummy_counter()
        
      self.flushAllActivities()
      self.assertEquals(call_count, 10)
    finally:
      SQLQueue.MAX_MESSAGE_LIST_SIZE = old_MAX_MESSAGE_LIST_SIZE
      del Organisation.dummy_counter

  def test_MAX_MESSAGE_LIST_SIZE_SQLDict(self):
    from Products.CMFActivity.Activity import SQLDict
    old_MAX_MESSAGE_LIST_SIZE = SQLDict.MAX_MESSAGE_LIST_SIZE
    SQLDict.MAX_MESSAGE_LIST_SIZE = 3

    try:
      global call_count
      call_count = 0
      def dummy_counter(self):
        global call_count
        call_count += 1

      o = self.portal.organisation_module.newContent(portal_type='Organisation',)

      for i in range(10):
        method_name = 'dummy_counter_%s' % i
        setattr(Organisation, method_name, dummy_counter)
        getattr(o.activate(activity='SQLDict'), method_name)()
        
      self.flushAllActivities()
      self.assertEquals(call_count, 10)
    finally:
      SQLDict.MAX_MESSAGE_LIST_SIZE = old_MAX_MESSAGE_LIST_SIZE
      for i in range(10):
        method_name = 'dummy_counter_%s' % i
        delattr(Organisation, method_name)

3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118
  def test_115_TestSerializationTagSQLDictPreventsParallelExecution(self, quiet=0, run=run_all_test):
    """
      Test if there are multiple activities with the same serialization tag,
      then serialization tag guarantees that only one of the same serialization
      tagged activities can be processed at the same time.
    """
    if not run: return
    if not quiet:
      message = '\n'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    from Products.CMFActivity import ActivityTool

    portal = self.getPortal()
    activity_tool = portal.portal_activities
    self.tic()

    # Add 6 activities
    portal.organisation_module.activate(activity='SQLDict', tag='', serialization_tag='test_115').getId()
3119
    self.commit()
3120
    portal.organisation_module.activate(activity='SQLDict', serialization_tag='test_115').getTitle()
3121
    self.commit()
3122
    portal.organisation_module.activate(activity='SQLDict', tag='tag_1', serialization_tag='test_115').getId()
3123
    self.commit()
3124
    portal.person_module.activate(activity='SQLDict', serialization_tag='test_115').getId()
3125
    self.commit()
3126
    portal.person_module.activate(activity='SQLDict', tag='tag_2').getId()
3127
    self.commit()
3128
    portal.organisation_module.activate(activity='SQLDict', tag='', serialization_tag='test_115').getId()
3129
    self.commit()
3130 3131 3132

    # distribute and assign them to 3 nodes
    activity_tool.distribute()
3133
    self.commit()
3134 3135 3136

    from Products.CMFActivity import ActivityTool
    ActivityTool.activity_dict['SQLDict'].getProcessableMessageList(activity_tool, 1)
3137
    self.commit()
3138
    ActivityTool.activity_dict['SQLDict'].getProcessableMessageList(activity_tool, 2)
3139
    self.commit()
3140
    ActivityTool.activity_dict['SQLDict'].getProcessableMessageList(activity_tool, 3)
3141
    self.commit()
3142 3143 3144 3145 3146 3147 3148 3149 3150

    result = activity_tool.SQLDict_readMessageList(include_processing=1,
                                                   processing_node=None,
                                                   path=None,
                                                   method_id=None,
                                                   to_date=None,
                                                   offset=0,
                                                   count=1000)

3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172
    try:
      self.assertEqual(len([message
                            for message in result
                            if (message.processing_node>0 and
                                message.processing==1 and
                                message.serialization_tag=='test_115')]),
                       1)

      self.assertEqual(len([message
                            for message in result
                            if (message.processing_node==-1 and
                                message.serialization_tag=='test_115')]),
                       3)

      self.assertEqual(len([message
                            for message in result
                            if (message.processing_node>0 and
                                message.processing==1 and
                                message.serialization_tag=='')]),
                       1)
    finally:
      # Clear activities from all nodes
3173 3174
      activity_tool.SQLBase_delMessage(table=SQLDict.sql_table,
                                       uid=[message.uid for message in result])
3175
      self.commit()
3176

3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188
  def test_116_RaiseInCommitBeforeMessageExecution(self):
    """
      Test behaviour of CMFActivity when the commit just before message
      execution fails. In particular, CMFActivity should restart the
      activities it selected (processing=1) instead of ignoring them forever.
    """
    processed = []
    activity_tool = self.portal.portal_activities
    activity_tool.__class__.doSomething = processed.append
    try:
      for activity in 'SQLDict', 'SQLQueue':
        activity_tool.activate(activity=activity).doSomething(activity)
3189
        self.commit()
3190 3191 3192 3193 3194
        activity_tool.distribute()
        # Make first commit in dequeueMessage raise
        registerFailingTransactionManager()
        self.assertRaises(CommitFailed, activity_tool.tic)
        # Normally, the request stops here and Zope aborts the transaction
3195
        self.abort()
3196 3197 3198 3199 3200 3201 3202 3203
        self.assertEqual(processed, [])
        # Activity is already in 'processing=1' state. Check tic reselects it.
        activity_tool.tic()
        self.assertEqual(processed, [activity])
        del processed[:]
    finally:
      del activity_tool.__class__.doSomething

3204 3205 3206 3207 3208 3209
  def test_117_PlacelessDefaultReindexParameters(self):
    """
      Test behaviour of PlacelessDefaultReindexParameters.
    """
    portal = self.portal
    
3210 3211 3212 3213 3214 3215
    # Make a new Person object to make sure that the portal type
    # is migrated to an instance of a portal type class, otherwise
    # the portal type may generate an extra active object.
    portal.person_module.newContent(portal_type='Person')
    self.tic()

3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228
    original_reindex_parameters = portal.getPlacelessDefaultReindexParameters()
    if original_reindex_parameters is None:
      original_reindex_parameters = {}
    
    tag = 'SOME_RANDOM_TAG'      
    activate_kw = original_reindex_parameters.get('activate_kw', {}).copy()
    activate_kw['tag'] = tag 
    portal.setPlacelessDefaultReindexParameters(activate_kw=activate_kw, \
                                                **original_reindex_parameters)
    current_default_reindex_parameters = portal.getPlacelessDefaultReindexParameters()
    self.assertEquals({'activate_kw': {'tag': tag}}, \
                       current_default_reindex_parameters)
    person = portal.person_module.newContent(portal_type='Person')
3229
    self.commit()
3230 3231 3232 3233 3234 3235 3236 3237 3238
    # as we specified it in setPlacelessDefaultReindexParameters we should have
    # an activity for this tags
    self.assertEquals(1, portal.portal_activities.countMessageWithTag(tag))
    self.tic()
    self.assertEquals(0, portal.portal_activities.countMessageWithTag(tag))
    
    # restore originals ones
    portal.setPlacelessDefaultReindexParameters(**original_reindex_parameters)
    person = portal.person_module.newContent(portal_type='Person')
Łukasz Nowak's avatar
Łukasz Nowak committed
3239
    # .. now no messages with this tag should apper
3240 3241
    self.assertEquals(0, portal.portal_activities.countMessageWithTag(tag))    

3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261
  def TryNotificationSavedOnEventLogWhenNotifyUserRaises(self, activity):
    activity_tool = self.getActivityTool()
    self.tic()
    obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    original_notifyUser = Message.notifyUser
    def failSendingEmail(self, *args, **kw):
      raise MailHostError, 'Mail is not sent'
    Message.notifyUser = failSendingEmail
    class ActivityUnitTestError(Exception):
      pass
    activity_unit_test_error = ActivityUnitTestError()
    def failingMethod(self):
      raise activity_unit_test_error
    Organisation.failingMethod = failingMethod
    self._catch_log_errors(ignored_level=sys.maxint) 

    try:
      import traceback
      obj.activate(activity=activity, priority=6).failingMethod()
3262
      self.commit()
3263 3264 3265 3266 3267 3268
      self.flushAllActivities(silent=1, loop_size=100)   
      message_list = activity_tool.getMessageList()
      self.assertEqual(len(message_list), 1)
      message = message_list[0]
      logged_errors = []
      logged_errors = self.logged
3269
      self.commit()
3270 3271 3272
      for log_record in self.logged:
        if log_record.name == 'ActivityTool' and log_record.levelname == 'WARNING':
          type, value, trace = log_record.exc_info
3273
      self.commit()
3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320
      self.assertTrue(activity_unit_test_error is value)
    finally:
      self._ignore_log_errors()
      Message.notifyUser = original_notifyUser
      delattr(Organisation, 'failingMethod')

  def test_118_userNotificationSavedOnEventLogWhenNotifyUserRaisesWithSQLDict(self, quiet=0, run=run_all_test):
    """
      Check the error is saved on event log even if the mail notification is not sent.
    """
    if not run: return
    if not quiet:
      message = '\nCheck the error is saved on event log even if the mail notification is not sent (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryNotificationSavedOnEventLogWhenNotifyUserRaises('SQLDict')

  def test_119_userNotificationSavedOnEventLogWhenNotifyUserRaisesWithSQLQueue(self, quiet=0, run=run_all_test):
    """
      Check the error is saved on event log even if the mail notification is not sent.
    """
    if not run: return
    if not quiet:
      message = '\nCheck the error is saved on event log even if the mail notification is not sent (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryNotificationSavedOnEventLogWhenNotifyUserRaises('SQLQueue') 

  def TryUserMessageContainingNoTracebackIsStillSent(self, activity):
    portal = self.getPortalObject()
    activity_tool = self.getActivityTool()
    # With Message.__call__
    # 1: activity context does not exist when activity is executed
    self.tic()
    obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
    notification_done = []
    def fake_notifyUser(self, *args, **kw):
      notification_done.append(True)
      self.traceback = None
    original_notifyUser = Message.notifyUser
    def failingMethod(self):
      raise ValueError, "This method always fail"
    Message.notifyUser = fake_notifyUser
    Organisation.failingMethod = failingMethod
    try:
      obj.activate(activity=activity).failingMethod()
3321
      self.commit()
3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359
      self.flushAllActivities(silent=1, loop_size=100)
      message_list = activity_tool.getMessageList()
      self.assertEqual(len(message_list), 1)
      self.assertEqual(len(notification_done), 1)
      message = message_list[0]
      self.assertEqual(message.traceback, None)
      message(activity_tool)
      activity_tool.manageCancel(message.object_path, message.method_id)
    finally:
      Message.notifyUser = original_notifyUser
      delattr(Organisation, 'failingMethod')    

  def test_120_sendMessageWithNoTracebackWithSQLQueue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that message with no traceback is still sent (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryUserMessageContainingNoTracebackIsStillSent('SQLQueue')

  def test_121_sendMessageWithNoTracebackWithSQLDict(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that message with no traceback is still sent (SQLDict)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryUserMessageContainingNoTracebackIsStillSent('SQLDict')
  
  def TryNotificationSavedOnEventLogWhenSiteErrorLoggerRaises(self, activity):
    # Make sure that no active object is installed.
    activity_tool = self.getPortal().portal_activities
    activity_tool.manageClearActivities(keep=0)

    # Need an object.
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
    o = organisation_module._getOb(self.company_id)
3360
    self.commit()
3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
    self.flushAllActivities(silent = 1, loop_size = 10)
    self.assertEquals(len(activity_tool.getMessageList()), 0)
    class ActivityUnitTestError(Exception):
      pass
    activity_unit_test_error = ActivityUnitTestError()
    def failingMethod(self):
      raise activity_unit_test_error
    from Products.SiteErrorLog.SiteErrorLog import SiteErrorLog
    SiteErrorLog.original_raising = SiteErrorLog.raising

    # Monkey patch Site Error to induce conflict errors artificially.
    def raising(self, info):
      from Products.SiteErrorLog.SiteErrorLog import SiteErrorLog
      raise AttributeError
      return self.original_raising(info)
    from Products.SiteErrorLog.SiteErrorLog import SiteErrorLog
    SiteErrorLog.original_raising = SiteErrorLog.raising
    SiteErrorLog.raising = raising
    Organisation.failingMethod = failingMethod
    self._catch_log_errors(ignored_level=sys.maxint)

    try:
      o.activate(activity = activity).failingMethod()
3384
      self.commit()
3385 3386 3387 3388
      self.assertEquals(len(activity_tool.getMessageList()), 1)
      self.flushAllActivities(silent = 1)
      SiteErrorLog.raising = SiteErrorLog.original_raising
      logged_errors = self.logged
3389
      self.commit()
3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
      for log_record in self.logged:
        if log_record.name == 'ActivityTool' and log_record.levelname == 'WARNING':
          type, value, trace = log_record.exc_info     
      self.assertTrue(activity_unit_test_error is value)
    finally:
      self._ignore_log_errors()
      SiteErrorLog.raising = SiteErrorLog.original_raising
      delattr(Organisation, 'failingMethod')
      del SiteErrorLog.original_raising

  def test_122_userNotificationSavedOnEventLogWhenSiteErrorLoggerRaisesWithSQLDict(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that message not saved in site error logger is not lost'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryNotificationSavedOnEventLogWhenSiteErrorLoggerRaises('SQLDict')

  def test_123_userNotificationSavedOnEventLogWhenSiteErrorLoggerRaisesWithSQLQueue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      message = '\nCheck that message not saved in site error logger is not lost'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryNotificationSavedOnEventLogWhenSiteErrorLoggerRaises('SQLQueue')
3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439

  def test_124_checkConflictErrorAndNoRemainingActivities(self):
    """
    When an activity creates several activities, make sure that all newly
    created activities are not commited if there is ZODB Conflict error
    """
    from Products.CMFActivity.Activity import SQLQueue
    old_MAX_MESSAGE_LIST_SIZE = SQLQueue.MAX_MESSAGE_LIST_SIZE
    SQLQueue.MAX_MESSAGE_LIST_SIZE = 1
    try:
      activity_tool = self.getPortal().portal_activities
      def doSomething(self):
        self.serialize()
        self.activate(activity='SQLQueue').getId()
        self.activate(activity='SQLQueue').getTitle()
        conn = self._p_jar
        tid = self._p_serial
        oid = self._p_oid
        try:
          conn.db().invalidate({oid: tid})
        except TypeError:
          conn.db().invalidate(tid, {oid: tid})
        
      activity_tool.__class__.doSomething = doSomething
      activity_tool.activate(activity='SQLQueue').doSomething()
3440
      self.commit()
3441 3442 3443 3444 3445 3446 3447
      activity_tool.distribute()
      activity_tool.tic()
      message_list = activity_tool.getMessageList()
      self.assertEquals(['doSomething'],[x.method_id for x in message_list])
      activity_tool.manageClearActivities(keep=0)
    finally:
      SQLQueue.MAX_MESSAGE_LIST_SIZE = old_MAX_MESSAGE_LIST_SIZE
3448 3449 3450 3451 3452 3453 3454 3455

  def test_125_CheckDistributeWithSerializationTagAndGroupMethodId(self):
    activity_tool = self.portal.portal_activities
    obj1 = activity_tool.newActiveProcess()
    obj2 = activity_tool.newActiveProcess()
    self.tic()
    group_method_call_list = []
    def doSomething(self, message_list):
3456 3457
      group_method_call_list.append(sorted((ob.getPath(), args, kw)
                                           for ob, args, kw, _ in message_list))
3458 3459 3460 3461 3462 3463 3464
    activity_tool.__class__.doSomething = doSomething
    try:
      for activity in 'SQLDict', 'SQLQueue':
        activity_kw = dict(activity=activity, serialization_tag=self.id(),
                           group_method_id='portal_activities/doSomething')
        obj1.activate(**activity_kw).dummy(1, x=None)
        obj2.activate(**activity_kw).dummy(2, y=None)
3465
        self.commit()
3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476
        activity_tool.distribute()
        activity_tool.tic()
        self.assertEqual(group_method_call_list.pop(),
                         sorted([(obj1.getPath(), (1,), dict(x=None)),
                                 (obj2.getPath(), (2,), dict(y=None))]))
        self.assertFalse(group_method_call_list)
        self.assertFalse(activity_tool.getMessageList())
        obj1.activate(priority=2, **activity_kw).dummy1(1, x=None)
        obj1.activate(priority=1, **activity_kw).dummy2(2, y=None)
        message1 = obj1.getPath(), (1,), dict(x=None)
        message2 = obj1.getPath(), (2,), dict(y=None)
3477
        self.commit()
3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488
        activity_tool.distribute()
        self.assertEqual(len(activity_tool.getMessageList()), 2)
        activity_tool.tic()
        self.assertEqual(group_method_call_list.pop(),
                         dict(SQLDict=[message2],
                              SQLQueue=[message1, message2])[activity])
        self.assertFalse(group_method_call_list)
        self.assertFalse(activity_tool.getMessageList())
    finally:
      del activity_tool.__class__.doSomething

3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500
  def test_126_beforeCommitHook(self):
    """
    Check it is possible to activate an object from a before commit hook
    """
    def doSomething(person):
      person.activate(activity='SQLDict')._setFirstName('John')
      person.activate(activity='SQLQueue')._setLastName('Smith')
    person = self.portal.person_module.newContent()
    transaction.get().addBeforeCommitHook(doSomething, (person,))
    self.tic()
    self.assertEqual(person.getTitle(), 'John Smith')

3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544
  def test_connection_migration(self):
    """
    Make sure the cmf_activity_sql_connection is automatically migrated from
    the ZMySQLDA Connection class to ActivityConnection
    """
    # replace the activity connector with a standard ZMySQLDA one
    portal = self.portal
    activity_tool = portal.portal_activities
    stdconn = self.portal.cmf_activity_sql_connection
    portal._delObject('cmf_activity_sql_connection')
    portal.manage_addProduct['ZMySQLDA'].manage_addZMySQLConnection(
        stdconn.id,
        stdconn.title,
        stdconn.connection_string,
    )
    oldconn = portal.cmf_activity_sql_connection
    self.assertEquals(oldconn.meta_type, 'Z MySQL Database Connection')
    # de-initialize and check that migration of the connection happens
    # automatically
    Products.CMFActivity.ActivityTool.is_initialized = False
    activity_tool.activate(activity='SQLQueue').getId()
    self.tic()
    newconn = portal.cmf_activity_sql_connection
    self.assertEquals(newconn.meta_type, 'CMFActivity Database Connection')

  def test_connection_installable(self):
    """
    Test if the cmf_activity_sql_connector can be installed
    """
    # delete the activity connection
    portal = self.portal
    activity_tool = portal.portal_activities
    stdconn = self.portal.cmf_activity_sql_connection
    portal._delObject('cmf_activity_sql_connection')
    # check the installation form can be rendered
    portal.manage_addProduct['CMFActivity'].connectionAdd(
        portal.REQUEST
    )
    # check it can be installed
    portal.manage_addProduct['CMFActivity'].manage_addActivityConnection(
        stdconn.id,
        stdconn.title,
        stdconn.connection_string
    )
3545 3546
    newconn = portal.cmf_activity_sql_connection
    self.assertEquals(newconn.meta_type, 'CMFActivity Database Connection')
3547

3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
  def test_onErrorCallback(self):
    activity_tool = self.portal.portal_activities
    obj = activity_tool.newActiveProcess()
    self.tic()
    def _raise(exception): # I wish exceptions are callable raising themselves
      raise exception
    def doSomething(self, conflict_error, cancel):
      self.activity_count += 1
      error = ConflictError() if conflict_error else Exception()
      def onError(exc_type, exc_value, traceback):
        assert exc_value is error
        env = self.getActivityRuntimeEnvironment()
        weakref_list.extend(map(weakref.ref, (env, env._message)))
        self.on_error_count += 1
        return cancel
      self.getActivityRuntimeEnvironment().edit(on_error_callback=onError)
      if not self.on_error_count:
        if not conflict_error:
          raise error
        transaction.get().addBeforeCommitHook(_raise, (error,))
    obj.__class__.doSomething = doSomething
    try:
      for activity in 'SQLDict', 'SQLQueue':
        for conflict_error in False, True:
          weakref_list = []
          obj.activity_count = obj.on_error_count = 0
          obj.activate(activity=activity).doSomething(conflict_error, True)
          self.tic()
          self.assertEqual(obj.activity_count, 0)
          self.assertEqual(obj.on_error_count, 1)
          gc.collect()
          self.assertEqual([x() for x in weakref_list], [None, None])
          weakref_list = []
          obj.activate(activity=activity).doSomething(conflict_error, False)
          obj.on_error_count = 0
          self.tic()
          self.assertEqual(obj.activity_count, 1)
          self.assertEqual(obj.on_error_count, 1)
          gc.collect()
          self.assertEqual([x() for x in weakref_list], [None, None])
    finally:
      del obj.__class__.doSomething

3591 3592 3593 3594
  def test_duplicateGroupedMessage(self):
    activity_tool = self.portal.portal_activities
    obj = activity_tool.newActiveProcess()
    obj.reindexObject(activate_kw={'tag': 'foo', 'after_tag': 'bar'})
3595
    self.commit()
3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607
    invoked = []
    def invokeGroup(self, *args):
      invoked.append(len(args[1]))
      return ActivityTool_invokeGroup(self, *args)
    ActivityTool_invokeGroup = activity_tool.__class__.invokeGroup
    try:
      activity_tool.__class__.invokeGroup = invokeGroup
      self.tic()
    finally:
      activity_tool.__class__.invokeGroup = ActivityTool_invokeGroup
    self.assertEqual(invoked, [1])

Jérome Perrin's avatar
Jérome Perrin committed
3608 3609 3610 3611
def test_suite():
  suite = unittest.TestSuite()
  suite.addTest(unittest.makeSuite(TestCMFActivity))
  return suite
Sebastien Robin's avatar
Sebastien Robin committed
3612