testCMFActivity.py 127 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
##############################################################################
#
# 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.
#
##############################################################################

29
import inspect
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
Sebastien Robin's avatar
Sebastien Robin committed
33 34
from Testing import ZopeTestCase
from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
35
from Products.ERP5Type.tests.utils import createZODBPythonScript
36
from Products.ERP5Type.Base import Base
37
from Products.CMFActivity.Activity.SQLBase import INVOKE_ERROR_STATE
38
from Products.CMFActivity.Activity.Queue import VALIDATION_ERROR_DELAY
39
from Products.CMFActivity.Activity.SQLDict import SQLDict
40
import Products.CMFActivity.ActivityTool
41
from Products.CMFActivity.Errors import ActivityPendingError, ActivityFlushError
42
from erp5.portal_type import Organisation
43
from AccessControl.SecurityManagement import newSecurityManager
Sebastien Robin's avatar
Sebastien Robin committed
44
from zLOG import LOG
45
from ZODB.POSException import ConflictError
46
from DateTime import DateTime
47
from Products.CMFActivity.ActivityTool import Message
48 49
from _mysql_exceptions import OperationalError
from Products.ZMySQLDA.db import DB
50
import gc
51
import random
52
import threading
53
import weakref
54
import transaction
55

Julien Muchembled's avatar
Julien Muchembled committed
56 57 58 59 60 61 62 63 64 65 66 67 68 69
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()

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

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

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

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

  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)

101
  def afterSetUp(self):
102
    super(TestCMFActivity, self).afterSetUp()
103 104 105 106
    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
107
    self.login()
108
    portal = self.portal
109 110 111 112 113
    # 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)
114

Sebastien Robin's avatar
Sebastien Robin committed
115 116 117 118 119 120 121 122
    # 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)
123
    self.tic()
Sebastien Robin's avatar
Sebastien Robin committed
124 125 126 127

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

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

Yoshinori Okuji's avatar
Yoshinori Okuji committed
163
  def DeferredSetTitleActivity(self, activity):
164 165 166 167
    """
    We check that the title is changed only after that
    the activity was called
    """
Sebastien Robin's avatar
Sebastien Robin committed
168
    portal = self.getPortal()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
169
    organisation = portal.organisation._getOb(self.company_id)
170
    organisation._setTitle(self.title1)
171
    self.assertEqual(self.title1,organisation.getTitle())
172
    organisation.activate(activity=activity)._setTitle(self.title2)
Sebastien Robin's avatar
Sebastien Robin committed
173
    # Needed so that the message are commited into the queue
174
    self.commit()
175
    self.assertEqual(self.title1,organisation.getTitle())
Sebastien Robin's avatar
Sebastien Robin committed
176
    portal.portal_activities.tic()
177
    self.assertEqual(self.title2,organisation.getTitle())
Sebastien Robin's avatar
Sebastien Robin committed
178
    message_list = portal.portal_activities.getMessageList()
179
    self.assertEqual(len(message_list),0)
Sebastien Robin's avatar
Sebastien Robin committed
180

181
  def CallOnceWithActivity(self, activity):
182 183 184 185
    """
    With this test we can check if methods are called
    only once (sometimes it was twice !!!)
    """
Sebastien Robin's avatar
Sebastien Robin committed
186
    portal = self.getPortal()
187 188 189 190 191 192 193
    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
194
    organisation =  portal.organisation._getOb(self.company_id)
195 196 197
    Organisation.setFoobar = setFoobar
    Organisation.getFoobar = getFoobar
    organisation.foobar = 0
198
    organisation._setTitle(self.title1)
199
    self.assertEqual(0,organisation.getFoobar())
200
    organisation.activate(activity=activity).setFoobar()
Sebastien Robin's avatar
Sebastien Robin committed
201
    # Needed so that the message are commited into the queue
202
    self.commit()
203
    message_list = portal.portal_activities.getMessageList()
204
    self.assertEqual(len(message_list),1)
Sebastien Robin's avatar
Sebastien Robin committed
205
    portal.portal_activities.tic()
206
    self.assertEqual(1,organisation.getFoobar())
Sebastien Robin's avatar
Sebastien Robin committed
207
    message_list = portal.portal_activities.getMessageList()
208
    self.assertEqual(len(message_list),0)
209 210
    organisation.activate(activity=activity).setFoobar()
    # Needed so that the message are commited into the queue
211
    self.commit()
212
    message_list = portal.portal_activities.getMessageList()
213
    self.assertEqual(len(message_list),1)
214 215
    portal.portal_activities.manageInvoke(organisation.getPhysicalPath(),'setFoobar')
    # Needed so that the message are commited into the queue
216
    self.commit()
217
    message_list = portal.portal_activities.getMessageList()
218 219
    self.assertEqual(len(message_list),0)
    self.assertEqual(2,organisation.getFoobar())
220

221
  def TryFlushActivity(self, activity):
222 223 224
    """
    Check the method flush
    """
225 226
    portal = self.getPortal()
    organisation =  portal.organisation._getOb(self.company_id)
227 228
    organisation._setTitle(self.title1)
    organisation.activate(activity=activity)._setTitle(self.title2)
229
    organisation.flushActivity(invoke=1)
230
    self.assertEqual(organisation.getTitle(),self.title2)
231
    self.commit()
232
    message_list = portal.portal_activities.getMessageList()
233 234
    self.assertEqual(len(message_list),0)
    self.assertEqual(organisation.getTitle(),self.title2)
235
    # Try again with different commit order
236 237
    organisation._setTitle(self.title1)
    organisation.activate(activity=activity)._setTitle(self.title2)
238
    self.commit()
239
    organisation.flushActivity(invoke=1)
240 241
    self.assertEqual(len(message_list),0)
    self.assertEqual(organisation.getTitle(),self.title2)
242
    self.commit()
243

244
  def TryActivateInsideFlush(self, activity):
245 246 247
    """
    Create a new activity inside a flush action
    """
248 249
    portal = self.getPortal()
    def DeferredSetTitle(self,value):
250
      self.activate(activity=activity)._setTitle(value)
251 252
    Organisation.DeferredSetTitle = DeferredSetTitle
    organisation =  portal.organisation._getOb(self.company_id)
253
    organisation._setTitle(self.title1)
254 255
    organisation.activate(activity=activity).DeferredSetTitle(self.title2)
    organisation.flushActivity(invoke=1)
256
    self.commit()
257
    portal.portal_activities.tic()
258
    self.commit()
259
    message_list = portal.portal_activities.getMessageList()
260 261
    self.assertEqual(len(message_list),0)
    self.assertEqual(organisation.getTitle(),self.title2)
262 263

  def TryTwoMethods(self, activity):
264 265 266
    """
    Try several activities
    """
267 268
    portal = self.getPortal()
    def DeferredSetDescription(self,value):
269
      self._setDescription(value)
270
    def DeferredSetTitle(self,value):
271
      self._setTitle(value)
272 273 274
    Organisation.DeferredSetTitle = DeferredSetTitle
    Organisation.DeferredSetDescription = DeferredSetDescription
    organisation =  portal.organisation._getOb(self.company_id)
275
    organisation._setTitle(None)
276 277 278
    organisation.setDescription(None)
    organisation.activate(activity=activity).DeferredSetTitle(self.title1)
    organisation.activate(activity=activity).DeferredSetDescription(self.title1)
279
    self.commit()
280 281
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
282
    self.commit()
283
    message_list = portal.portal_activities.getMessageList()
284 285 286
    self.assertEqual(len(message_list),0)
    self.assertEqual(organisation.getTitle(),self.title1)
    self.assertEqual(organisation.getDescription(),self.title1)
287 288

  def TryTwoMethodsAndFlushThem(self, activity):
289 290 291
    """
    make sure flush works with several activities
    """
292 293
    portal = self.getPortal()
    def DeferredSetTitle(self,value):
294
      self.activate(activity=activity)._setTitle(value)
295
    def DeferredSetDescription(self,value):
296
      self.activate(activity=activity)._setDescription(value)
297 298 299
    Organisation.DeferredSetTitle = DeferredSetTitle
    Organisation.DeferredSetDescription = DeferredSetDescription
    organisation =  portal.organisation._getOb(self.company_id)
300
    organisation._setTitle(None)
301 302 303 304
    organisation.setDescription(None)
    organisation.activate(activity=activity).DeferredSetTitle(self.title1)
    organisation.activate(activity=activity).DeferredSetDescription(self.title1)
    organisation.flushActivity(invoke=1)
305
    self.commit()
306 307
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
308
    self.commit()
309
    message_list = portal.portal_activities.getMessageList()
310 311 312
    self.assertEqual(len(message_list),0)
    self.assertEqual(organisation.getTitle(),self.title1)
    self.assertEqual(organisation.getDescription(),self.title1)
313

314
  def TryActivateFlushActivateTic(self, activity,second=None,commit_sub=0):
315 316 317
    """
    try to commit sub transactions
    """
318 319 320
    portal = self.getPortal()
    def DeferredSetTitle(self,value,commit_sub=0):
      if commit_sub:
321
        transaction.savepoint(optimistic=True)
322
      self.activate(activity=second or activity,priority=4)._setTitle(value)
323 324
    def DeferredSetDescription(self,value,commit_sub=0):
      if commit_sub:
325
        transaction.savepoint(optimistic=True)
326
      self.activate(activity=second or activity,priority=4)._setDescription(value)
327 328 329
    Organisation.DeferredSetTitle = DeferredSetTitle
    Organisation.DeferredSetDescription = DeferredSetDescription
    organisation =  portal.organisation._getOb(self.company_id)
330
    organisation._setTitle(None)
331 332 333 334
    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)
335
    self.commit()
336 337
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
338
    self.commit()
339
    message_list = portal.portal_activities.getMessageList()
340 341 342
    self.assertEqual(len(message_list),0)
    self.assertEqual(organisation.getTitle(),self.title1)
    self.assertEqual(organisation.getDescription(),self.title1)
343

344
  def TryMessageWithErrorOnActivity(self, activity):
345 346 347
    """
    Make sure that message with errors are not deleted
    """
348 349
    portal = self.getPortal()
    def crashThisActivity(self):
350
      self.IWillCrash()
351 352 353 354
    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
355
    self.commit()
356
    message_list = portal.portal_activities.getMessageList()
357
    LOG('Before MessageWithErrorOnActivityFails, message_list',0,[x.__dict__ for x in message_list])
358
    self.assertEqual(len(message_list),1)
359
    portal.portal_activities.tic()
360
    # XXX HERE WE SHOULD USE TIME SHIFT IN ORDER TO SIMULATE MULTIPLE TICS
361 362
    # Test if there is still the message after it crashed
    message_list = portal.portal_activities.getMessageList()
363
    self.assertEqual(len(message_list),1)
364 365
    portal.portal_activities.manageCancel(organisation.getPhysicalPath(),'crashThisActivity')
    # Needed so that the message are commited into the queue
366
    self.commit()
367
    message_list = portal.portal_activities.getMessageList()
368
    self.assertEqual(len(message_list),0)
369

Yoshinori Okuji's avatar
Yoshinori Okuji committed
370
  def DeferredSetTitleWithRenamedObject(self, activity):
371
    """
372 373
    make sure that it is impossible to rename an object
    if some activities are still waiting for this object
374 375 376
    """
    portal = self.getPortal()
    organisation =  portal.organisation._getOb(self.company_id)
377
    organisation._setTitle(self.title1)
378
    self.assertEqual(self.title1,organisation.getTitle())
379
    organisation.activate(activity=activity)._setTitle(self.title2)
380
    # Needed so that the message are commited into the queue
381
    self.commit()
382
    self.assertEqual(self.title1,organisation.getTitle())
383
    self.assertRaises(ActivityPendingError,organisation.edit,id=self.company_id2)
384 385 386 387 388 389 390 391
    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)
392
    organisation._setTitle(self.title1)
393
    active_process = portal.portal_activities.newActiveProcess()
394
    self.assertEqual(self.title1,organisation.getTitle())
395 396
    organisation.activate(activity=activity,active_process=active_process).getTitle()
    # Needed so that the message are commited into the queue
397
    self.commit()
398 399
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
400
    self.assertEqual(self.title1,organisation.getTitle())
401
    result = active_process.getResultList()[0]
402 403
    self.assertEqual(result.method_id , 'getTitle')
    self.assertEqual(result.result , self.title1)
404
    message_list = portal.portal_activities.getMessageList()
405
    self.assertEqual(len(message_list),0)
406

407 408
  def TryMethodAfterMethod(self, activity):
    """
409
      Ensure the order of an execution by a method id
410 411
    """
    portal = self.getPortal()
412 413 414 415
    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)
416

417
    o.setTitle('a')
418
    self.assertEqual(o.getTitle(), 'a')
419
    self.tic()
420

421 422 423
    def toto(self, value):
      self.setTitle(self.getTitle() + value)
    o.__class__.toto = toto
424

425 426 427
    def titi(self, value):
      self.setTitle(self.getTitle() + value)
    o.__class__.titi = titi
428

429 430 431
    o.activate(after_method_id = 'titi', activity = activity).toto('b')
    o.activate(activity = activity).titi('c')
    self.tic()
432
    self.assertEqual(o.getTitle(), 'acb')
433

434 435 436 437 438 439 440 441 442
  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)
443

444
    o.setTitle('?')
445
    self.assertEqual(o.getTitle(), '?')
446
    self.tic()
447

448 449 450
    o.activate(after_tag = 'toto', activity = activity).setTitle('b')
    o.activate(tag = 'toto', activity = activity).setTitle('a')
    self.tic()
451
    self.assertEqual(o.getTitle(), 'b')
452

453
    o.setDefaultActivateParameterDict({'tag': 'toto'})
454 455 456 457 458 459
    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()
460
    self.assertEqual(o.getCorporateName(), 'cd')
461

462 463 464 465 466 467 468 469 470 471 472 473
  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('?')
474 475
    self.assertEqual(o.getTitle(), '?')
    self.assertEqual(o.getDescription(), '?')
476 477 478 479
    self.tic()

    o.activate(after_tag = 'toto', activity = activity).setDescription('b')
    o.activate(tag = 'toto', activity = activity).setTitle('a')
480
    self.commit()
481 482 483
    tool = self.getActivityTool()
    self.assertRaises(ActivityFlushError,tool.manageInvoke,o.getPath(),'setDescription')
    tool.manageInvoke(o.getPath(),'setTitle')
484
    self.commit()
485 486
    self.assertEqual(o.getTitle(), 'a')
    self.assertEqual(o.getDescription(), '?')
487
    self.tic()
488 489 490
    self.assertEqual(len(tool.getMessageList()),0)
    self.assertEqual(o.getTitle(), 'a')
    self.assertEqual(o.getDescription(), 'b')
491

Yoshinori Okuji's avatar
Yoshinori Okuji committed
492 493 494 495 496 497 498 499 500
  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)
501

Yoshinori Okuji's avatar
Yoshinori Okuji committed
502
    o.setTitle('?')
503
    self.assertEqual(o.getTitle(), '?')
Yoshinori Okuji's avatar
Yoshinori Okuji committed
504
    self.tic()
505

Yoshinori Okuji's avatar
Yoshinori Okuji committed
506 507 508
    def toto(self, s):
      self.setTitle(self.getTitle() + s)
    o.__class__.toto = toto
509

Yoshinori Okuji's avatar
Yoshinori Okuji committed
510
    o.activate(tag = 'toto', activity = activity).toto('a')
511
    self.commit()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
512
    o.activate(after_tag = 'titi', activity = activity).toto('b')
513
    self.commit()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
514 515
    o.activate(tag = 'titi', after_tag = 'toto', activity = activity).setTitle('c')
    self.tic()
516
    self.assertEqual(o.getTitle(), 'cb')
517

518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
  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')
537
    self.commit()
538
    o.activate(tag='B', activity=activity).toto('b')
539
    self.commit()
540 541
    o.activate(after_tag=('A', 'B'), activity=activity).setTitle('last')
    self.tic()
542
    self.assertEqual(o.getTitle(), 'last')
543

544 545 546 547 548 549 550 551 552 553 554 555 556 557
  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')
558
    self.commit()
559 560
    self.assertEqual(o.getTitle(), '?')
    self.assertEqual(portal_activities.countMessageWithTag('toto'), 1)
561
    self.tic()
562 563
    self.assertEqual(o.getTitle(), 'a')
    self.assertEqual(portal_activities.countMessageWithTag('toto'), 0)
564

565 566 567 568 569
  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
570
    activity_tool.manageClearActivities()
571 572 573 574 575 576

    # 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)
577
    self.commit()
578
    self.flushAllActivities(silent = 1, loop_size = 10)
579
    self.assertEqual(len(activity_tool.getMessageList()), 0)
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598

    # 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()
599
        self.commit()
600
        self.flushAllActivities(silent = 1, loop_size = i + 10)
601
        self.assertEqual(len(activity_tool.getMessageList()), 0)
602 603 604 605 606 607
    finally:
      Queue.validate = Queue.original_validate
      del Queue.original_validate
      del Queue.current_num_conflict_errors
      del Queue.conflict_errors_limit

608 609 610 611 612
  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
613
    activity_tool.manageClearActivities()
614 615 616 617 618 619

    # 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)
620
    self.commit()
621
    self.flushAllActivities(silent=1, loop_size=10)
622
    self.assertEqual(len(activity_tool.getMessageList()), 0)
623 624 625

    # Monkey patch Queue to induce conflict errors artificially.
    def query(self, query_string,*args, **kw):
626 627
      # Not so nice, this is specific to zsql method
      if "REPLACE INTO" in query_string:
628
        raise OperationalError
629
      return self.original_query(query_string,*args, **kw)
630 631
    portal = self.getPortal()

632 633 634 635
    # Test some range of conflict error occurences.
    organisation_module.recursiveReindexObject()
    self.commit()
    self.assertTrue(len(activity_tool.getMessageList()), 1)
636 637 638 639 640
    try:
      DB.original_query = DB.query
      DB.query = query
      portal.portal_activities.distribute()
      portal.portal_activities.tic()
641
      self.commit()
642 643 644
    finally:
      DB.query = DB.original_query
      del DB.original_query
645
    self.assertEqual(len(portal.portal_activities.getMessageList()), 1)
646

647 648 649 650 651 652
  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)
653
    activity_tool.manageClearActivities()
654
    self.commit()
655
    # First case: creating the same activity twice must only register one.
656
    self.assertEqual(len(activity_tool.getMessageList()), 0) # Sanity check
657 658
    object_a.activate(activity=activity).getId()
    object_a.activate(activity=activity).getId()
659
    self.commit()
660
    self.assertEqual(len(activity_tool.getMessageList()), 1)
661
    activity_tool.manageClearActivities()
662
    self.commit()
663 664
    # Second case: creating activity with same tag must only register one.
    # This behaviour is actually the same as the no-tag behaviour.
665
    self.assertEqual(len(activity_tool.getMessageList()), 0) # Sanity check
666 667
    object_a.activate(activity=activity, tag='foo').getId()
    object_a.activate(activity=activity, tag='foo').getId()
668
    self.commit()
669
    self.assertEqual(len(activity_tool.getMessageList()), 1)
670
    activity_tool.manageClearActivities()
671
    self.commit()
672
    # Third case: creating activities with different tags must register both.
673
    self.assertEqual(len(activity_tool.getMessageList()), 0) # Sanity check
674 675
    object_a.activate(activity=activity, tag='foo').getId()
    object_a.activate(activity=activity, tag='bar').getId()
676
    self.commit()
677
    self.assertEqual(len(activity_tool.getMessageList()), 2)
678
    activity_tool.manageClearActivities()
679
    self.commit()
680 681
    # Fourth case: creating activities on different objects must register
    # both.
682
    self.assertEqual(len(activity_tool.getMessageList()), 0) # Sanity check
683 684
    object_a.activate(activity=activity).getId()
    object_b.activate(activity=activity).getId()
685
    self.commit()
686
    self.assertEqual(len(activity_tool.getMessageList()), 2)
687
    activity_tool.manageClearActivities()
688
    self.commit()
689 690
    # Fifth case: creating activities with different method must register
    # both.
691
    self.assertEqual(len(activity_tool.getMessageList()), 0) # Sanity check
692 693
    object_a.activate(activity=activity).getId()
    object_a.activate(activity=activity).getTitle()
694
    self.commit()
695
    self.assertEqual(len(activity_tool.getMessageList()), 2)
696
    activity_tool.manageClearActivities()
697
    self.commit()
698

Yoshinori Okuji's avatar
Yoshinori Okuji committed
699
  def test_01_DeferredSetTitleSQLDict(self, quiet=0, run=run_all_test):
700 701 702
    # Test if we can add a complete sales order
    if not run: return
    if not quiet:
Yoshinori Okuji's avatar
Yoshinori Okuji committed
703
      message = '\nTest Deferred Set Title SQLDict '
704 705
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
706
    self.DeferredSetTitleActivity('SQLDict')
707

Yoshinori Okuji's avatar
Yoshinori Okuji committed
708
  def test_02_DeferredSetTitleSQLQueue(self, quiet=0, run=run_all_test):
709 710 711
    # Test if we can add a complete sales order
    if not run: return
    if not quiet:
Yoshinori Okuji's avatar
Yoshinori Okuji committed
712
      message = '\nTest Deferred Set Title SQLQueue '
713 714
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
715
    self.DeferredSetTitleActivity('SQLQueue')
716

Sebastien Robin's avatar
Sebastien Robin committed
717 718 719 720 721 722 723
  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)
724
    self.InvokeAndCancelActivity('SQLDict')
Sebastien Robin's avatar
Sebastien Robin committed
725 726 727 728 729 730 731 732

  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)
733
    self.InvokeAndCancelActivity('SQLQueue')
Sebastien Robin's avatar
Sebastien Robin committed
734

735 736 737 738 739 740 741 742 743 744
  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
745 746 747 748 749 750
    # 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)
751 752
    self.CallOnceWithActivity('SQLQueue')

753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
  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')

771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
  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')

789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
  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')

843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
  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)

889 890 891 892 893 894 895
  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
896
    self.DeferredSetTitleWithRenamedObject('SQLDict')
897 898 899 900 901 902 903 904

  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
905
    self.DeferredSetTitleWithRenamedObject('SQLQueue')
906 907 908 909 910 911 912 913 914

  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
915

916 917 918 919 920 921 922 923
  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
924

925 926 927 928
  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:
929
      message = '\nTry Active Method After Another Activate Method With SQLDict'
930 931 932
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.TryMethodAfterMethod('SQLDict')
933

934 935 936 937 938 939 940 941
  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')
942

943
  def test_56_TryCallActivityWithRightUser(self, quiet=0, run=run_all_test):
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
    # 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)
964
    self.commit()
965 966 967 968
    portal.portal_activities.distribute()
    portal.portal_activities.tic()
    email = organisation.get('email')
    # Check if what we did was executed as toto
969
    self.assertEqual(email.getOwnerInfo()['id'],'toto')
970

971 972 973 974 975 976 977 978 979
  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')

980
  def test_60_TryAfterTagWithSQLQueue(self, quiet=0, run=run_all_test):
981 982 983 984 985 986 987 988
    # 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
989 990 991 992 993 994 995 996 997
  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')

998
  def test_62_CheckSchedulingWithSQLQueue(self, quiet=0, run=run_all_test):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
999 1000 1001 1002 1003 1004 1005 1006
    # 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')

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
  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')

1025
  def flushAllActivities(self, silent=0, loop_size=1000):
1026 1027 1028 1029
    """Executes all messages until the queue only contains failed
    messages.
    """
    activity_tool = self.getPortal().portal_activities
1030
    for _ in xrange(loop_size):
1031 1032
      activity_tool.distribute(node_count=1)
      activity_tool.tic(processing_node=1)
1033

1034 1035
      finished = 1
      for message in activity_tool.getMessageList():
1036
        if message.processing_node != INVOKE_ERROR_STATE:
1037 1038 1039
          finished = 0

      activity_tool.timeShift(3 * VALIDATION_ERROR_DELAY)
1040
      self.commit()
1041
      if finished:
1042
        return
1043 1044
    if not silent:
      self.fail('flushAllActivities maximum loop count reached')
1045 1046 1047 1048 1049 1050 1051

  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
1052 1053 1054 1055 1056 1057
    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."""
1058 1059 1060 1061 1062 1063
    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
1064
    original_title = 'something'
1065
    obj = self.getPortal().organisation_module.newContent(
1066 1067 1068
                    portal_type='Organisation',
                    title=original_title)

1069 1070 1071 1072 1073 1074 1075 1076
    # Monkey patch Organisation to add a failing method
    def failingMethod(self):
      raise ValueError, 'This method always fail'
    Organisation.failingMethod = failingMethod

    activity_list = ['SQLQueue', 'SQLDict', ]
    for activity in activity_list:
      # reset
1077
      activity_tool.manageClearActivities()
1078
      obj.setTitle(original_title)
1079
      self.commit()
1080 1081 1082 1083

      # activate failing message and flush
      for fail_activity in activity_list:
        obj.activate(activity = fail_activity).failingMethod()
1084
      self.commit()
1085 1086 1087 1088 1089 1090 1091 1092 1093
      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')

1094 1095 1096 1097
      # activate our message
      new_title = 'nothing'
      obj.activate(after_method_id = ['failingMethod'],
                   activity = activity ).setTitle(new_title)
1098
      self.commit()
1099 1100 1101 1102 1103 1104 1105 1106
      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')
1107
      self.assertEqual(remaining_messages[0].activity_kw['after_method_id'],
1108
          ['failingMethod'])
1109
      self.assertEqual(obj.getTitle(), original_title)
1110

1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
  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')

1122 1123
  def test_67_TestCancelFailedActiveObject(self, quiet=0, run=run_all_test):
    """Cancel an active object to make sure that it does not refer to
1124 1125 1126 1127
    a persistent object.

    XXX: this test fails if run first
    """
1128 1129 1130 1131 1132 1133
    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
1134
    activity_tool.manageClearActivities()
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146

    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

    # First, index the object.
1147
    self.commit()
1148
    self.flushAllActivities(silent=1, loop_size=100)
1149
    self.assertEqual(len(activity_tool.getMessageList()), 0)
1150 1151 1152

    # Insert a failing active object.
    obj.activate().failingMethod()
1153
    self.commit()
1154
    self.assertEqual(len(activity_tool.getMessageList()), 1)
1155 1156

    # Just wait for the active object to be abandoned.
1157
    self.flushAllActivities(silent=1, loop_size=100)
1158
    self.assertEqual(len(activity_tool.getMessageList()), 1)
1159
    self.assertEqual(activity_tool.getMessageList()[0].processing_node,
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
                      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)
1170
    self.commit()
1171
    self.assertEqual(len(activity_tool.getMessageList()), 0)
1172

1173
  def test_68_RetryMessageExecution(self, quiet=0):
1174
    if not quiet:
1175
      message = '\nCheck number of executions of failing activities'
1176 1177
      ZopeTestCase._print(message)
      LOG('Testing... ', 0, message)
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
    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:
1190
        raise ConflictError if conflict else Exception
1191
    def check(retry_list, **activate_kw):
1192 1193 1194
      fail = retry_list[-1][0] is not None and 1 or 0
      for activity in 'SQLDict', 'SQLQueue':
        exec_count[0] = 0
1195 1196
        activity_tool.activate(activity=activity, priority=priority(1,6),
                               **activate_kw).doSomething(retry_list)
1197
        self.commit()
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
        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})])
1219
      check([(True, None)] * 6, conflict_retry=False)
1220 1221 1222 1223 1224 1225 1226 1227 1228
      # 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)])
1229

1230 1231 1232
    finally:
      del activity_tool.__class__.doSomething
    self.assertFalse(activity_tool.getMessageList())
1233

1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
  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')

1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
  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')

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
  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')

1294 1295 1296 1297 1298 1299 1300 1301 1302
  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'))
1303
    self.commit()
1304 1305 1306 1307
    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:
1308
      self.assertEqual(m.activity_kw.get('tag'), 'The Tag')
1309

1310

1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
  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()
1332
      self.commit()
1333

1334
    self.assertEqual(len(activity_tool.getMessageList()), 10)
1335 1336 1337 1338 1339 1340
    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()
1341
      self.commit()
1342 1343

    self.assertEqual(len(activity_tool.getMessageList()), 10)
1344
    activity_tool.flush(p, invoke=0)
1345
    self.commit()
1346 1347
    self.assertEqual(len(activity_tool.getMessageList()), 0)

1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
  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')

1359 1360
  def test_79_AbortTransactionSynchronously(self, quiet=0, run=run_all_test):
    """
1361 1362
      This test checks if transaction.abort() synchronizes connections. It
      didn't do so back in Zope 2.7
1363 1364 1365
    """
    if not run: return
    if not quiet:
1366
      message = '\nTest Aborting Transaction Synchronizes'
1367 1368 1369 1370 1371 1372 1373 1374
      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()
1375
    self.commit()
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
    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)

1391 1392
    # Access to invalidated object in non-MVCC connections should raise a
    # conflict error
1393 1394
    organisation = module[organisation_id]
    self.assertRaises(ReadConflictError, getattr, organisation, 'uid')
1395 1396

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

1399
    self.abort()
1400 1401
    getattr(organisation, 'uid')

1402

1403
  def callWithGroupIdParamater(self, activity, quiet, run):
1404 1405
    if not run: return
    if not quiet:
1406
      message = '\nTest Activity with group_id parameter (%s)' % activity
1407 1408 1409
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)

1410
    portal = self.getPortal()
1411 1412
    organisation =  portal.organisation._getOb(self.company_id)
    # Defined a group method
1413
    foobar_list = []
1414
    def setFoobar(self, object_list):
1415
      foobar_list.append(len(object_list))
1416
      for m in object_list:
1417 1418 1419
        obj = m.object
        obj.foobar = getattr(obj.aq_base, 'foobar', 0) + m.kw.get('number', 1)
        m.result = None
1420
    from Products.ERP5Type.Core.Folder import Folder
1421
    Folder.setFoobar = setFoobar
1422 1423 1424 1425 1426 1427

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

    organisation.foobar = 0
1428
    self.assertEqual(0,organisation.getFoobar())
1429 1430 1431

    # Test group_method_id is working without group_id
    for x in xrange(5):
1432
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar").reindexObject(number=1)
1433
      self.commit()
1434 1435

    message_list = portal.portal_activities.getMessageList()
1436
    self.assertEqual(len(message_list),5)
1437
    portal.portal_activities.tic()
1438
    expected = dict(SQLDict=1, SQLQueue=5)[activity]
1439
    self.assertEqual(expected, organisation.getFoobar())
1440 1441 1442 1443


    # Test group_method_id is working with one group_id defined
    for x in xrange(5):
1444
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="1").reindexObject(number=1)
1445
      self.commit()
1446 1447

    message_list = portal.portal_activities.getMessageList()
1448
    self.assertEqual(len(message_list),5)
1449
    portal.portal_activities.tic()
1450
    self.assertEqual(expected * 2, organisation.getFoobar())
1451

1452
    self.assertEqual([expected, expected], foobar_list)
1453
    del foobar_list[:]
1454 1455 1456

    # Test group_method_id is working with many group_id defined
    for x in xrange(5):
1457
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="1").reindexObject(number=1)
1458
      self.commit()
1459
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="2").reindexObject(number=3)
1460
      self.commit()
1461
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="1").reindexObject(number=1)
1462
      self.commit()
1463
      organisation.activate(activity=activity, group_method_id="organisation_module/setFoobar", group_id="3").reindexObject(number=5)
1464
      self.commit()
1465 1466

    message_list = portal.portal_activities.getMessageList()
1467
    self.assertEqual(len(message_list),20)
1468
    portal.portal_activities.tic()
1469
    self.assertEqual(dict(SQLDict=11, SQLQueue=60)[activity],
1470
                      organisation.getFoobar())
1471
    self.assertEqual(dict(SQLDict=[1, 1, 1], SQLQueue=[5, 5, 10])[activity],
1472
                      sorted(foobar_list))
1473
    message_list = portal.portal_activities.getMessageList()
1474
    self.assertEqual(len(message_list), 0)
1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487

  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)
1488

1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
  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'))
1501
    self.commit()
1502 1503 1504 1505
    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:
1506
      self.assertEqual(m.activity_kw.get('tag'), 'The Tag')
1507

1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
  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()
1520
    self.assertEqual(len(message_list), 0)
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
    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()
1534
    self.commit()
1535
    message_list = activity_tool.getMessageList()
1536
    self.assertEqual(len(message_list), 2)
1537

1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
  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'
1560 1561 1562 1563 1564 1565 1566
    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()
1567
      self.commit()
1568 1569 1570 1571
      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)
1572
      self.assertEqual(sorted(obj.getTitle()), ['a', 'b', 'd'])
1573 1574
    finally:
      delattr(Organisation, 'appendToTitle')
1575

1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
  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')

1610
  def TryUserNotificationOnActivityFailure(self, activity):
1611 1612 1613
    message_list = self.portal.MailHost._message_list
    del message_list[:]
    obj = self.portal.organisation_module.newContent(portal_type='Organisation')
1614
    self.tic()
1615
    def failingMethod(self): raise ValueError('This method always fails')
1616 1617
    Organisation.failingMethod = failingMethod
    try:
1618 1619
      # MESSAGE_NOT_EXECUTED
      obj.activate(activity=activity).failingMethod()
1620
      self.commit()
1621
      self.assertFalse(message_list)
1622
      self.flushAllActivities(silent=1, loop_size=100)
1623 1624 1625 1626 1627
      # Check there is a traceback in the email notification
      sender, recipients, mail = message_list.pop()
      self.assertTrue("Module %s, line %s, in failingMethod" % (
        __name__, inspect.getsourcelines(failingMethod)[1]) in mail, mail)
      self.assertTrue("ValueError:" in mail, mail)
1628 1629
      # MESSAGE_NOT_EXECUTABLE
      obj.getParentValue()._delObject(obj.getId())
1630
      obj.activate(activity=activity).failingMethod()
1631
      self.commit()
1632 1633 1634 1635
      self.assertTrue(obj.hasActivity())
      self.tic()
      self.assertFalse(obj.hasActivity())
      self.assertFalse(message_list)
1636
    finally:
1637
      del Organisation.failingMethod
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662

  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')

1663 1664 1665 1666 1667 1668 1669 1670 1671 1672
  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
1673
    getMessageList = self.getPortalObject().portal_activities.getMessageList
1674 1675
    try:
      obj.activate(activity=activity, priority=6).failingMethod()
1676
      self.commit()
1677
      self.flushAllActivities(silent=1, loop_size=100)
1678 1679
      message, = getMessageList(activity=activity, method_id='failingMethod')
      self.assertEqual(message.processing, 0)
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
    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')
1705

1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
  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()
    try:
      Organisation.registerFailingTransactionManager = registerFailingTransactionManager
      obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
      self.tic()
      now = DateTime()
      obj.activate(activity=activity).registerFailingTransactionManager()
1720
      self.commit()
1721
      self.flushAllActivities(silent=1, loop_size=100)
1722
      self.commit()
1723
      # Check that cmf_activity SQL connection still works
1724
      connection_da = self.getPortalObject().cmf_activity_sql_connection()
1725
      self.assertFalse(connection_da._registered)
1726
      connection_da.query('select 1')
1727
      self.assertTrue(connection_da._registered)
1728
      self.commit()
1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
      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')

1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
  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()
1760
      self.commit()
1761
      self.flushAllActivities(silent=1, loop_size=100)
1762
      self.commit()
1763
      self.assertEqual(activity_tool.countMessage(method_id='registerFailingTransactionManager'), 1)
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
    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')
1782

1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
  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()
1793
      self.commit()
1794
      self.assertEqual(len(activity_tool.getMessageList()), 1)
1795
      self.flushAllActivities(silent=1, loop_size=100)
1796
      self.assertEqual(len(activity_tool.getMessageList()), 0)
1797 1798 1799
    finally:
      delattr(Organisation, 'changeSkinToNone')

Vincent Pelletier's avatar
Vincent Pelletier committed
1800
  def test_100_TryChangeSkinInActivitySQLDict(self, quiet=0, run=run_all_test):
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
    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')
1815

1816 1817 1818 1819 1820
  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.
    """
1821 1822
    if not run: return
    if not quiet:
1823
      message = '\nCheck similarities are not deleted before execution of original message (SQLDict)'
1824 1825 1826
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    activity_tool = self.getActivityTool()
1827 1828 1829 1830
    marker = []
    def doSomething(self, other_tag):
      marker.append(self.countMessage(tag=other_tag))
    activity_tool.__class__.doSomething = doSomething
1831
    try:
1832
      # Adds two similar but not the same activities.
1833 1834 1835 1836
      activity_tool.activate(activity='SQLDict', after_tag='foo',
        tag='a').doSomething(other_tag='b')
      activity_tool.activate(activity='SQLDict', after_tag='bar',
        tag='b').doSomething(other_tag='a')
1837
      self.commit()
1838
      activity_tool.tic() # make sure distribution phase was not skipped
1839 1840 1841
      activity_tool.distribute()
      # after distribute, similarities are still there.
      self.assertEqual(len(activity_tool.getMessageList()), 2)
1842
      activity_tool.tic()
1843
      self.assertEqual(len(activity_tool.getMessageList()), 0)
1844
      self.assertEqual(marker, [1])
1845
    finally:
1846
      del activity_tool.__class__.doSomething
1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858

  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)
    activity_tool = self.getActivityTool()
1859 1860 1861 1862
    marker = []
    def doSomething(self, other_tag):
      marker.append(self.countMessage(tag=other_tag))
    activity_tool.__class__.doSomething = doSomething
1863 1864
    try:
      # Adds two same activities.
1865 1866
      activity_tool.activate(activity='SQLDict', after_tag='foo', priority=2,
        tag='a').doSomething(other_tag='a')
1867
      self.commit()
1868
      uid1, = [x.uid for x in activity_tool.getMessageList()]
1869 1870
      activity_tool.activate(activity='SQLDict', after_tag='bar', priority=1,
        tag='a').doSomething(other_tag='a')
1871
      self.commit()
1872 1873 1874
      self.assertEqual(len(activity_tool.getMessageList()), 2)
      activity_tool.distribute()
      # After distribute, duplicate is deleted.
1875 1876
      uid2, = [x.uid for x in activity_tool.getMessageList()]
      self.assertNotEqual(uid1, uid2)
1877
      activity_tool.tic()
1878
      self.assertEqual(len(activity_tool.getMessageList()), 0)
1879
      self.assertEqual(marker, [1])
1880
    finally:
1881
      del activity_tool.__class__.doSomething
1882

1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
  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()
1896
    self.commit()
1897 1898
    organisation.activate(serialization_tag='a',
              group_method_id='portal_catalog/catalogObjectList').getTitle()
1899
    self.commit()
1900 1901 1902 1903 1904 1905 1906
    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)

1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925
  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()
1926
      self.commit()
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
      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')
1958 1959

  def CheckActivityRuntimeEnvironment(self, activity):
1960 1961
    document = self.portal.organisation_module
    activity_result = []
1962
    def extractActivityRuntimeEnvironment(self):
1963 1964
      activity_result.append(self.getActivityRuntimeEnvironment())
    document.__class__.doSomething = extractActivityRuntimeEnvironment
1965
    try:
1966
      document.activate(activity=activity).doSomething()
1967
      self.commit()
1968 1969
      # Check that getActivityRuntimeEnvironment raises outside of activities
      self.assertRaises(KeyError, document.getActivityRuntimeEnvironment)
1970
      # Check Runtime isolation
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983
      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')
1984
    finally:
1985
      del document.__class__.doSomething
1986

Vincent Pelletier's avatar
Vincent Pelletier committed
1987
  def test_104_activityRuntimeEnvironmentSQLDict(self, quiet=0, run=run_all_test):
1988 1989 1990 1991 1992 1993 1994
    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
1995
  def test_105_activityRuntimeEnvironmentSQLQueue(self, quiet=0, run=run_all_test):
1996 1997 1998 1999 2000 2001 2002
    if not run: return
    if not quiet:
      message = '\nCheck ActivityRuntimeEnvironment (SQLQueue)'
      ZopeTestCase._print(message)
      LOG('Testing... ',0,message)
    self.CheckActivityRuntimeEnvironment('SQLQueue')

2003 2004 2005 2006 2007 2008 2009 2010 2011
  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()
2012
    self.commit()
2013 2014 2015 2016 2017 2018 2019
    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()
2020
    self.commit()
2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
    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)
2031
    organisation.activate(activity=activity, serialization_tag='1', priority=2).getTitle()
2032
    # Use a different method just so that SQLDict doesn't merge both activities prior to insertion.
2033
    organisation.activate(activity=activity, serialization_tag='1', priority=1).getId()
2034
    self.commit()
2035 2036 2037 2038
    result = activity_tool.getMessageList()
    self.assertEqual(len(result), 2)
    activity_tool.distribute()
    result = activity_tool.getMessageList()
2039 2040 2041 2042 2043 2044
    # 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')
2045 2046
    self.tic()
    result = activity_tool.getMessageList()
2047
    self.assertEqual(len(result), 0)
2048 2049 2050 2051 2052
    # 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)
2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069

  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')

2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
  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')
2087
      self.assertEqual(o.absolute_url(),
2088 2089
          'http://test.erp5.org:9080/virtual_root/test_obj')
      o.activate().checkAbsoluteUrl()
2090

2091 2092 2093 2094 2095 2096 2097
      # 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
2098
      self.assertEqual(o.absolute_url(),
2099 2100 2101 2102 2103
          '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)
2104
      self.assertEqual(calls, ['http://test.erp5.org:9080/virtual_root/test_obj'])
2105 2106 2107
    finally:
      delattr(Organisation, 'checkAbsoluteUrl')

2108 2109 2110 2111 2112
  def CheckLocalizerWorks(self, activity):
    FROM_STRING = 'Foo'
    TO_STRING = 'Bar'
    LANGUAGE = 'xx'
    def translationTest(context):
2113
      from Products.ERP5Type.Message import Message
2114
      context.setTitle(context.Base_translateString(FROM_STRING))
2115
      context.setDescription(str(Message('erp5_ui', FROM_STRING)))
2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
    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:
2128 2129 2130
      REQUEST = organisation.REQUEST
      # Simulate what a browser would have sent to Zope
      REQUEST.environ['HTTP_ACCEPT_LANGUAGE'] = LANGUAGE
2131
      organisation.activate(activity=activity).translationTest()
2132
      self.commit()
2133 2134 2135
      # Remove request parameter to check that it was saved at activate call
      # and restored at message execution.
      del REQUEST.environ['HTTP_ACCEPT_LANGUAGE']
2136 2137 2138 2139
      self.tic()
    finally:
      delattr(Organisation, 'translationTest')
    self.assertEqual(TO_STRING, organisation.getTitle())
2140
    self.assertEqual(TO_STRING, organisation.getDescription())
2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157

  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')

2158
  def test_114_checkSQLQueueActivitySucceedsAfterActivityChangingSkin(self,
2159
    quiet=0, run=run_all_test):
2160 2161 2162 2163 2164
    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)
2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188
    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()
2189
      self.commit()
2190 2191 2192 2193 2194 2195 2196
      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)
2197
      self.assertEqual(len(activity_tool.getMessageList()), 0)
2198 2199 2200 2201
    finally:
      delattr(Organisation, 'firstTest')
      delattr(Organisation, 'secondTest')

2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216
  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)
2217
    #
2218 2219 2220 2221
    # 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
2222
    #   This is not perfect though, since it would require to have access to
2223 2224 2225 2226 2227 2228
    #   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()
2229 2230
    activity_event = threading.Event()
    rendez_vous_event = threading.Event()
2231 2232
    def waitingActivity(context):
      # Inform test that we arrived at rendez-vous.
2233 2234 2235
      rendez_vous_event.set()
      # When this event is available, it means test has called process_shutdown.
      activity_event.wait()
2236 2237
    from Products.CMFActivity.Activity.SQLDict import SQLDict
    original_dequeue = SQLDict.dequeueMessage
2238
    queue_tic_test_dict = {}
2239
    def dequeueMessage(self, activity_tool, processing_node):
2240
      # This is a one-shot method, revert after execution
2241 2242 2243
      SQLDict.dequeueMessage = original_dequeue
      result = self.dequeueMessage(activity_tool, processing_node)
      queue_tic_test_dict['isAlive'] = process_shutdown_thread.isAlive()
2244
      return result
2245
    SQLDict.dequeueMessage = dequeueMessage
2246 2247
    Organisation.waitingActivity = waitingActivity
    try:
Vincent Pelletier's avatar
Vincent Pelletier committed
2248
      # Use SQLDict with no group method so that both activities won't be
2249 2250
      # executed in the same batch, letting activity tool a chance to check
      # if execution should stop processing activities.
2251 2252
      organisation.activate(activity='SQLDict', tag='foo').waitingActivity()
      organisation.activate(activity='SQLDict', after_tag='foo').getTitle()
2253
      self.commit()
2254 2255
      self.assertEqual(len(activity_tool.getMessageList()), 2)
      activity_tool.distribute()
2256
      self.commit()
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280

      # 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.
2281
      rendez_vous_event.wait()
2282 2283 2284 2285
      # Initiate shutdown
      process_shutdown_thread.start()
      try:
        # Let waiting activity finish and wait for thread exit
2286
        activity_event.set()
2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302
        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()
2303
        except StandardException:
2304 2305 2306 2307 2308 2309
          # 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')
2310
      SQLDict.dequeueMessage = original_dequeue
2311 2312

  def test_hasActivity(self):
2313 2314
    active_object = self.portal.organisation_module.newContent(
                                            portal_type='Organisation')
2315
    active_process = self.portal.portal_activities.newActiveProcess()
2316
    self.tic()
2317

2318
    self.assertFalse(active_object.hasActivity())
2319 2320 2321 2322 2323
    self.assertFalse(active_process.hasActivity())

    def test(obj, **kw):
      for activity in ('SQLDict', 'SQLQueue'):
        active_object.activate(activity=activity, **kw).getTitle()
2324
        self.commit()
2325 2326 2327 2328 2329 2330 2331
        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())
2332

2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 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 2399 2400 2401
  def _test_hasErrorActivity_error(self, activity):
    # Monkey patch Organisation to add a failing method
    def failingMethod(self):
      raise ValueError('This method always fail')
    Organisation.failingMethod = failingMethod
    active_object = self.portal.organisation_module.newContent(
                                            portal_type='Organisation')
    active_process = self.portal.portal_activities.newActiveProcess()
    self.tic()


    self.assertFalse(active_object.hasErrorActivity())
    self.assertFalse(active_process.hasErrorActivity())

    active_object.activate(
      activity=activity, active_process=active_process).failingMethod()
    self.commit()
    # assert that any activity is created
    self.assertTrue(active_object.hasActivity())
    self.assertTrue(active_process.hasActivity())
    # assert that no error is reported
    self.assertFalse(active_object.hasErrorActivity())
    self.assertFalse(active_process.hasErrorActivity())
    self.flushAllActivities()
    # assert that any activity is created
    self.assertTrue(active_object.hasActivity())
    self.assertTrue(active_process.hasActivity())
    # assert that an error has been seen
    self.assertTrue(active_object.hasErrorActivity())
    self.assertTrue(active_process.hasErrorActivity())

  def test_hasErrorActivity_error_SQLQueue(self):
    self._test_hasErrorActivity_error('SQLQueue')

  def test_hasErrorActivity_error_SQLDict(self):
    self._test_hasErrorActivity_error('SQLDict')

  def _test_hasErrorActivity(self, activity):
    active_object = self.portal.organisation_module.newContent(
                                            portal_type='Organisation')
    active_process = self.portal.portal_activities.newActiveProcess()
    self.tic()

    self.assertFalse(active_object.hasErrorActivity())
    self.assertFalse(active_process.hasErrorActivity())

    active_object.activate(
      activity=activity, active_process=active_process).getTitle()
    self.commit()
    # assert that any activity is created
    self.assertTrue(active_object.hasActivity())
    self.assertTrue(active_process.hasActivity())
    # assert that no error is reported
    self.assertFalse(active_object.hasErrorActivity())
    self.assertFalse(active_process.hasErrorActivity())
    self.flushAllActivities()
    # assert that any activity is created
    self.assertFalse(active_object.hasActivity())
    self.assertFalse(active_process.hasActivity())
    # assert that no error is reported
    self.assertFalse(active_object.hasErrorActivity())
    self.assertFalse(active_process.hasErrorActivity())

  def test_hasErrorActivity_SQLQueue(self):
    self._test_hasErrorActivity('SQLQueue')

  def test_hasErrorActivity_SQLDict(self):
    self._test_hasErrorActivity('SQLDict')

2402 2403 2404
  def test_active_object_hasActivity_does_not_catch_exceptions(self):
    """
    Some time ago, hasActivity was doing a silent try/except, and this was
2405
    a possible disaster for some projects. Here we make sure that if the
2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
    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()
2421
      self.commit()
2422 2423 2424 2425 2426 2427 2428 2429 2430
      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
2431

2432 2433 2434
  def test_MAX_MESSAGE_LIST_SIZE(self):
    from Products.CMFActivity.Activity import SQLBase
    MAX_MESSAGE_LIST_SIZE = SQLBase.MAX_MESSAGE_LIST_SIZE
2435
    try:
2436 2437 2438 2439
      SQLBase.MAX_MESSAGE_LIST_SIZE = 3
      def dummy_counter(o):
        self.__call_count += 1
      o = self.portal.organisation_module.newContent(portal_type='Organisation')
2440

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452
      for activity in "SQLDict", "SQLQueue":
        self.__call_count = 0
        try:
          for i in xrange(10):
            method_name = 'dummy_counter_%s' % i
            getattr(o.activate(activity=activity), method_name)()
            setattr(Organisation, method_name, dummy_counter)
          self.flushAllActivities()
        finally:
          for i in xrange(10):
            delattr(Organisation, 'dummy_counter_%s' % i)
        self.assertEqual(self.__call_count, 10)
2453
    finally:
2454
      SQLBase.MAX_MESSAGE_LIST_SIZE = MAX_MESSAGE_LIST_SIZE
2455

2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474
  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()
2475
    self.commit()
2476
    portal.organisation_module.activate(activity='SQLDict', serialization_tag='test_115').getTitle()
2477
    self.commit()
2478
    portal.organisation_module.activate(activity='SQLDict', tag='tag_1', serialization_tag='test_115').getId()
2479
    self.commit()
2480
    portal.person_module.activate(activity='SQLDict', serialization_tag='test_115').getId()
2481
    self.commit()
2482
    portal.person_module.activate(activity='SQLDict', tag='tag_2').getId()
2483
    self.commit()
2484
    portal.organisation_module.activate(activity='SQLDict', tag='', serialization_tag='test_115').getId()
2485
    self.commit()
2486 2487 2488

    # distribute and assign them to 3 nodes
    activity_tool.distribute()
2489
    self.commit()
2490 2491

    from Products.CMFActivity import ActivityTool
2492 2493
    activity = ActivityTool.activity_dict['SQLDict']
    activity.getProcessableMessageList(activity_tool, 1)
2494
    self.commit()
2495
    activity.getProcessableMessageList(activity_tool, 2)
2496
    self.commit()
2497
    activity.getProcessableMessageList(activity_tool, 3)
2498
    self.commit()
2499

2500
    result = activity._getMessageList(activity_tool)
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
    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
2523 2524
      activity_tool.SQLBase_delMessage(table=SQLDict.sql_table,
                                       uid=[message.uid for message in result])
2525
      self.commit()
2526

2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
  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)
2539
        self.commit()
2540 2541 2542 2543
        # Make first commit in dequeueMessage raise
        registerFailingTransactionManager()
        self.assertRaises(CommitFailed, activity_tool.tic)
        # Normally, the request stops here and Zope aborts the transaction
2544
        self.abort()
2545 2546 2547 2548 2549 2550 2551 2552
        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

2553 2554 2555 2556 2557
  def test_117_PlacelessDefaultReindexParameters(self):
    """
      Test behaviour of PlacelessDefaultReindexParameters.
    """
    portal = self.portal
2558

2559 2560 2561 2562 2563 2564
    # 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()

2565 2566 2567
    original_reindex_parameters = portal.getPlacelessDefaultReindexParameters()
    if original_reindex_parameters is None:
      original_reindex_parameters = {}
2568 2569

    tag = 'SOME_RANDOM_TAG'
2570
    activate_kw = original_reindex_parameters.get('activate_kw', {}).copy()
2571
    activate_kw['tag'] = tag
2572 2573 2574
    portal.setPlacelessDefaultReindexParameters(activate_kw=activate_kw, \
                                                **original_reindex_parameters)
    current_default_reindex_parameters = portal.getPlacelessDefaultReindexParameters()
2575
    self.assertEqual({'activate_kw': {'tag': tag}}, \
2576 2577
                       current_default_reindex_parameters)
    person = portal.person_module.newContent(portal_type='Person')
2578
    self.commit()
2579 2580
    # as we specified it in setPlacelessDefaultReindexParameters we should have
    # an activity for this tags
2581
    self.assertEqual(1, portal.portal_activities.countMessageWithTag(tag))
2582
    self.tic()
2583
    self.assertEqual(0, portal.portal_activities.countMessageWithTag(tag))
2584

2585 2586 2587
    # restore originals ones
    portal.setPlacelessDefaultReindexParameters(**original_reindex_parameters)
    person = portal.person_module.newContent(portal_type='Person')
Łukasz Nowak's avatar
Łukasz Nowak committed
2588
    # .. now no messages with this tag should apper
2589
    self.assertEqual(0, portal.portal_activities.countMessageWithTag(tag))
2590

2591 2592 2593 2594 2595
  def TryNotificationSavedOnEventLogWhenNotifyUserRaises(self, activity):
    activity_tool = self.getActivityTool()
    self.tic()
    obj = self.getPortal().organisation_module.newContent(portal_type='Organisation')
    self.tic()
2596
    original_notifyUser = Message.notifyUser.im_func
2597 2598
    def failSendingEmail(self, *args, **kw):
      raise MailHostError, 'Mail is not sent'
2599
    activity_unit_test_error = Exception()
2600 2601 2602
    def failingMethod(self):
      raise activity_unit_test_error
    try:
2603 2604 2605
      Message.notifyUser = failSendingEmail
      Organisation.failingMethod = failingMethod
      self._catch_log_errors()
2606
      obj.activate(activity=activity, priority=6).failingMethod()
2607
      self.commit()
2608
      self.flushAllActivities(silent=1, loop_size=100)
2609
      message, = activity_tool.getMessageList()
2610
      self.commit()
2611 2612 2613
      for log_record in self.logged:
        if log_record.name == 'ActivityTool' and log_record.levelname == 'WARNING':
          type, value, trace = log_record.exc_info
2614
      self.commit()
2615 2616 2617
      self.assertTrue(activity_unit_test_error is value)
    finally:
      Message.notifyUser = original_notifyUser
2618 2619
      del Organisation.failingMethod
      self._ignore_log_errors()
2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640

  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)
2641
    self.TryNotificationSavedOnEventLogWhenNotifyUserRaises('SQLQueue')
2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661

  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()
2662
      self.commit()
2663 2664 2665 2666 2667 2668 2669 2670 2671 2672
      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
2673
      delattr(Organisation, 'failingMethod')
2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689

  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')
2690

2691 2692 2693
  def TryNotificationSavedOnEventLogWhenSiteErrorLoggerRaises(self, activity):
    # Make sure that no active object is installed.
    activity_tool = self.getPortal().portal_activities
2694
    activity_tool.manageClearActivities()
2695 2696 2697 2698 2699 2700

    # 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)
2701
    self.commit()
2702
    self.flushAllActivities(silent = 1, loop_size = 10)
2703
    self.assertEqual(len(activity_tool.getMessageList()), 0)
2704 2705 2706 2707 2708 2709
    class ActivityUnitTestError(Exception):
      pass
    activity_unit_test_error = ActivityUnitTestError()
    def failingMethod(self):
      raise activity_unit_test_error
    from Products.SiteErrorLog.SiteErrorLog import SiteErrorLog
2710
    original_raising = SiteErrorLog.raising.im_func
2711 2712 2713 2714 2715

    # Monkey patch Site Error to induce conflict errors artificially.
    def raising(self, info):
      raise AttributeError
    try:
2716 2717 2718
      SiteErrorLog.raising = raising
      Organisation.failingMethod = failingMethod
      self._catch_log_errors()
2719
      o.activate(activity = activity).failingMethod()
2720
      self.commit()
2721
      self.assertEqual(len(activity_tool.getMessageList()), 1)
2722
      self.flushAllActivities(silent = 1)
2723
      SiteErrorLog.raising = original_raising
2724
      self.commit()
2725 2726
      for log_record in self.logged:
        if log_record.name == 'ActivityTool' and log_record.levelname == 'WARNING':
2727
          type, value, trace = log_record.exc_info
2728 2729
      self.assertTrue(activity_unit_test_error is value)
    finally:
2730 2731
      SiteErrorLog.raising = original_raising
      del Organisation.failingMethod
2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
      self._ignore_log_errors()

  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')
2749 2750 2751 2752 2753 2754

  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
    """
2755 2756
    from Products.CMFActivity.Activity import SQLBase
    MAX_MESSAGE_LIST_SIZE = SQLBase.MAX_MESSAGE_LIST_SIZE
2757
    try:
2758
      SQLBase.MAX_MESSAGE_LIST_SIZE = 1
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770
      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})
2771

2772 2773
      activity_tool.__class__.doSomething = doSomething
      activity_tool.activate(activity='SQLQueue').doSomething()
2774
      self.commit()
2775 2776
      activity_tool.tic()
      message_list = activity_tool.getMessageList()
2777
      self.assertEqual(['doSomething'],[x.method_id for x in message_list])
2778
      activity_tool.manageClearActivities()
2779
    finally:
2780
      SQLBase.MAX_MESSAGE_LIST_SIZE = MAX_MESSAGE_LIST_SIZE
2781 2782 2783 2784 2785 2786 2787 2788

  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):
2789 2790
      r = []
      for m in message_list:
2791
        m.result = r.append((m.object.getPath(), m.args, m.kw))
2792 2793
      r.sort()
      group_method_call_list.append(r)
2794 2795 2796 2797 2798 2799 2800
    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)
2801
        self.commit()
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
        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)
2813
        self.commit()
2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
        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

2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
  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')

2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852
  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
2853
    self.assertEqual(oldconn.meta_type, 'Z MySQL Database Connection')
2854
    # force rebootstrap and check that migration of the connection happens
2855
    # automatically
2856 2857 2858
    from Products.ERP5Type.dynamic import portal_type_class
    portal_type_class._bootstrapped.clear()
    portal_type_class.synchronizeDynamicModules(activity_tool, True)
2859 2860 2861
    activity_tool.activate(activity='SQLQueue').getId()
    self.tic()
    newconn = portal.cmf_activity_sql_connection
2862
    self.assertEqual(newconn.meta_type, 'CMFActivity Database Connection')
2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882

  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
    )
2883
    newconn = portal.cmf_activity_sql_connection
2884
    self.assertEqual(newconn.meta_type, 'CMFActivity Database Connection')
2885

2886 2887 2888 2889 2890 2891 2892 2893 2894
  def test_connection_sortkey(self):
    """
    Check that SQL connection has properly initialized sort key,
    even when its container (ZODB connection) is reused by another thread.
    """
    def sortKey():
      app = ZopeTestCase.app()
      try:
        c = app[self.getPortalName()].cmf_activity_sql_connection()
2895
        return app._p_jar, c.sortKey()
2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907
      finally:
        ZopeTestCase.close(app)
    jar, sort_key = sortKey()
    self.assertNotEqual(1, sort_key)
    result = []
    t = threading.Thread(target=lambda: result.extend(sortKey()))
    t.daemon = True
    t.start()
    t.join()
    self.assertTrue(result[0] is jar)
    self.assertEqual(result[1], sort_key)

2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
  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

2951 2952 2953 2954
  def test_duplicateGroupedMessage(self):
    activity_tool = self.portal.portal_activities
    obj = activity_tool.newActiveProcess()
    obj.reindexObject(activate_kw={'tag': 'foo', 'after_tag': 'bar'})
2955
    self.commit()
2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
    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])

2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983
  def test_mergeParent(self):
    category_tool = self.portal.portal_categories
    # Test data:     c0
    #               /  \
    #             c1    c2
    #            /  \   |
    #           c3  c4  c5
    c = [category_tool.newContent()]
    for i in xrange(5):
      c.append(c[i//2].newContent())
    self.tic()
    def activate(i, priority=1, **kw):
      kw.setdefault('merge_parent', c[0].getPath())
      c[i].activate(priority=priority, **kw).doSomething()
    def check(*expected):
      self.tic()
2984
      self.assertEqual(tuple(invoked), expected)
2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010
      del invoked[:]
    invoked = []
    def doSomething(self):
      invoked.append(c.index(self))
    Base.doSomething = doSomething
    try:
      for t in (0, 1), (0, 4, 2), (1, 0, 5), (3, 2, 0):
        for p, i in enumerate(t):
          activate(i, p)
        check(0)
      activate(1, 0); activate(5, 1); check(1, 5)
      activate(3, 0); activate(1, 1); check(1)
      activate(2, 0); activate(1, 1); activate(4, 2); check(2, 1)
      activate(4, 0); activate(5, 1); activate(3, 2); check(4, 5, 3)
      activate(3, 0, merge_parent=c[1].getPath()); activate(0, 1); check(3, 0)
      # Following test shows that a child can be merged with a parent even if
      # 'merge_parent' is not specified. This can't be avoided without loading
      # all found duplicates, which would be bad for performance.
      activate(0, 0); activate(4, 1, merge_parent=None); check(0)
    finally:
      del Base.doSomething
    def activate(i, priority=1, **kw):
      c[i].activate(group_method_id='portal_categories/invokeGroup',
                    merge_parent=c[(i-1)//2 or i].getPath(),
                    priority=priority, **kw).doSomething()
    def invokeGroup(self, message_list):
3011 3012
      r = []
      for m in message_list:
3013
        m.result = r.append(c.index(m.object))
3014 3015
      r.sort()
      invoked.append(r)
3016 3017
    category_tool.__class__.invokeGroup = invokeGroup
    try:
3018
      activate(5, 0); activate(1, 1); check([1, 5])
3019 3020 3021 3022 3023 3024 3025 3026
      activate(4, 0); activate(1, 1); activate(2, 0); check([1, 2])
      activate(1, 0); activate(5, 0); activate(3, 1); check([1, 5])
      for p, i in enumerate((5, 3, 2, 1, 4)):
        activate(i, p, group_id=str(2 != i != 5))
      check([2], [1])
      for cost in 0.3, 0.1:
        activate(2, 0, group_method_cost=cost)
        activate(3, 1);  activate(4, 2); activate(1, 3)
3027
        check([1, 2])
3028 3029 3030 3031 3032
    finally:
      del category_tool.__class__.invokeGroup
    category_tool._delObject(c[0].getId())
    self.tic()

3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053
  def test_getMessageList(self):
    activity_tool = self.portal.portal_activities
    module = self.portal.person_module
    module.activate(after_tag="foo").getUid()
    module.activate(activity='SQLQueue', tag="foo").getId()
    activity_tool.activate(priority=-1).getId()
    def check(expected, **kw):
      self.assertEqual(expected, len(activity_tool.getMessageList(**kw)))
    def test(check=lambda _, **kw: check(0, **kw)):
      check(2, path=module.getPath())
      check(3, method_id=("getId", "getUid"))
      check(1, tag="foo")
      check(0, tag="foo", method_id="getUid")
      check(1, processing_node=-1)
      check(3, processing_node=range(-5,5))
    test()
    self.commit()
    test(check)
    self.tic()
    test()

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
  def test_MessageNonExecutable(self):
    message_list = self.portal.MailHost._message_list
    del message_list[:]
    activity_tool = self.portal.portal_activities
    kw = {}
    self._catch_log_errors(subsystem='CMFActivity')
    try:
      for kw['activity'] in 'SQLDict', 'SQLQueue':
        for kw['group_method_id'] in '', None:
          obj = activity_tool.newActiveProcess()
          self.tic()
          obj.activate(**kw).getId()
          activity_tool._delOb(obj.getId())
          obj = activity_tool.newActiveProcess(id=obj.getId(),
                                               is_indexable=False)
          self.commit()
          self.assertEqual(1, activity_tool.countMessage())
          self.flushAllActivities()
          sender, recipients, mail = message_list.pop()
          self.assertTrue('OID mismatch' in mail, mail)
          m, = activity_tool.getMessageList()
          self.assertEqual(m.processing_node, INVOKE_ERROR_STATE)
          obj.flushActivity()
          obj.activate(**kw).getId()
          activity_tool._delOb(obj.getId())
          self.commit()
          self.assertEqual(1, activity_tool.countMessage())
          activity_tool.tic()
          self.assertTrue('no object found' in self.logged.pop().getMessage())
    finally:
      self._ignore_log_errors()
    self.assertFalse(self.logged)
    self.assertFalse(message_list, message_list)

3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100
  def test_activateByPath(self):
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
      self.tic()
    organisation = organisation_module._getOb(self.company_id)
    portal.portal_activities.activateObject(
      organisation.getPath(),
      activity='SQLDict',
      active_process=None
      ).getTitle()
    self.tic()
3101

3102 3103 3104 3105 3106 3107 3108 3109 3110 3111
  def test_activateOnZsqlBrain(self):
    portal = self.getPortal()
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
      self.tic()
    organisation = organisation_module.searchFolder(id=self.company_id)[0]
    organisation.activate().getTitle()
    self.tic()

3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136
  def test_flushActivitiesOnDelete(self):
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
      self.tic()

    organisation = organisation_module[self.company_id]
    organisation_module.manage_delObjects(ids=[organisation.getId()])
    organisation.activate().getTitle()
    self.tic()

  def test_flushActivitiesOnDeleteWithAcquierableObject(self):
    organisation_module = self.getOrganisationModule()
    if not organisation_module.hasContent(self.company_id):
      organisation_module.newContent(id=self.company_id)
      self.tic()

    # Create an object with the same ID that can be acquired
    self.portal._setObject(self.company_id, Organisation(self.company_id))

    organisation = organisation_module[self.company_id]
    organisation_module.manage_delObjects(ids=[organisation.getId()])
    organisation.reindexObject()
    self.tic()

3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170
  def test_failingGroupMethod(self):
    activity_tool = self.portal.portal_activities
    obj = activity_tool.newActiveProcess()
    self.tic()
    obj.x = 1
    def doSomething(self):
      self.x %= self.x
    obj.__class__.doSomething = doSomething
    try:
      activity_kw = dict(activity="SQLQueue", group_method_id=None)
      obj.activate(**activity_kw).doSomething()
      obj.activate(**activity_kw).doSomething()
      obj.activate(**activity_kw).doSomething()
      self.commit()
      self.assertEqual(3, len(activity_tool.getMessageList()))
      activity_tool.tic()
      self.assertEqual(obj.x, 0)
      skipped, failed = activity_tool.getMessageList()
      self.assertEqual(0, skipped.retry)
      self.assertEqual(1, failed.retry)
      obj.x = 1
      self.commit()
      activity_tool.timeShift(VALIDATION_ERROR_DELAY)
      activity_tool.tic()
      m, = activity_tool.getMessageList()
      self.assertEqual(1, failed.retry)
      obj.x = 1
      self.commit()
      activity_tool.timeShift(VALIDATION_ERROR_DELAY)
      activity_tool.tic()
      self.assertFalse(activity_tool.getMessageList())
    finally:
      del obj.__class__.doSomething

3171 3172 3173
  def test_restrictedGroupMethod(self):
    skin = self.portal.portal_skins.custom
    script_id = self.id()
3174
    script = createZODBPythonScript(skin, script_id, "message_list", """if 1:
3175 3176 3177
      for m in message_list:
        m.result = m.object.getProperty(*m.args, **m.kw)
    """)
3178
    script.manage_proxy(("Manager",))
3179 3180
    obj = self.portal.portal_activities.newActiveProcess(causality_value_list=(
      self.portal.person_module, self.portal.organisation_module))
3181 3182
    obj.manage_permission('Access contents information', ['Manager'])
    self.logout()
3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193
    foo = obj.activate(activity='SQLQueue',
                       group_method_id=script_id,
                       active_process=obj.getPath()).foo
    foo('causality', portal_type='Organisation Module')
    foo('stop_date', 'bar')
    self.tic()
    self.assertEqual(sorted(x.getResult() for x in obj.getResultList()),
                     ['bar', 'organisation_module'])
    skin.manage_delObjects([script_id])
    self.tic()

Jérome Perrin's avatar
Jérome Perrin committed
3194 3195 3196 3197
def test_suite():
  suite = unittest.TestSuite()
  suite.addTest(unittest.makeSuite(TestCMFActivity))
  return suite
Sebastien Robin's avatar
Sebastien Robin committed
3198