testPackingList.py 36.6 KB
Newer Older
Sebastien Robin's avatar
Sebastien Robin committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
##############################################################################
#
# Copyright (c) 2004, 2005 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.
#
##############################################################################

#
# Skeleton ZopeTestCase
#

from random import randint

import os, sys
if __name__ == '__main__':
    execfile(os.path.join(sys.path[0], 'framework.py'))

# Needed in order to have a log file inside the current folder
os.environ['EVENT_LOG_FILE'] = os.path.join(os.getcwd(), 'zLOG.log')
os.environ['EVENT_LOG_SEVERITY'] = '-300'

from Testing import ZopeTestCase
from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
from AccessControl.SecurityManagement import newSecurityManager, \
                                             noSecurityManager
from DateTime import DateTime
from Acquisition import aq_base, aq_inner
from zLOG import LOG
from Products.ERP5Type.DateUtils import addToDate
from Products.ERP5Type.tests.Sequence import Sequence, SequenceList
import time
import os
from Products.ERP5Type import product_path
from Products.CMFCore.utils import getToolByName
56
from testOrder import TestOrderMixin
Sebastien Robin's avatar
Sebastien Robin committed
57

58
class TestPackingListMixin(TestOrderMixin):
Sebastien Robin's avatar
Sebastien Robin committed
59 60 61
  """
    Test business template erp5_trade 
  """
62
  packable_packing_list_portal_type_list = ['Sale Packing List']
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
  container_portal_type = 'Container'
  container_line_portal_type = 'Container Line'
  container_cell_portal_type = 'Container Cell'

  default_sequence = 'stepCreateOrganisation1 \
                      stepCreateOrganisation2 \
                      stepCreateOrganisation3 \
                      stepCreateOrder \
                      stepSetOrderProfile \
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
                      stepCheckPackingListIsNotDivergent '

85 86
  default_sequence_with_two_lines = '\
                      stepCreateOrganisation1 \
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
                      stepCreateOrganisation2 \
                      stepCreateOrganisation3 \
                      stepCreateOrder \
                      stepSetOrderProfile \
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
                      stepCheckPackingListIsNotDivergent '

109 110
  variated_default_sequence = '\
                      stepCreateOrganisation1 \
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
                      stepCreateOrganisation2 \
                      stepCreateOrganisation3 \
                      stepCreateOrder \
                      stepSetOrderProfile \
                      stepCreateVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepSetOrderLineFullVCL \
                      stepCompleteOrderLineMatrix \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
                      stepCheckPackingListIsNotDivergent '
129

Sebastien Robin's avatar
Sebastien Robin committed
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
  def getTitle(self):
    return "Packing List"

  def enableLightInstall(self):
    """
    You can override this. 
    Return if we should do a light install (1) or not (0)
    """
    return 1

  def enableActivityTool(self):
    """
    You can override this.
    Return if we should create (1) or not (0) an activity tool.
    """
    return 1

147 148
  def stepCheckPackingListIsDivergent(self, sequence=None, sequence_list=None, 
                                      packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
149 150 151
    """
      Test if packing list is divergent
    """
152 153
    if packing_list is None:
      packing_list = sequence.get('packing_list')
154 155
    self.failIf('Site Error' in packing_list.view())
    self.assertTrue(packing_list.isDivergent())
156 157 158 159 160 161

  def stepCheckNewPackingListIsDivergent(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is divergent
    """
    packing_list = sequence.get('new_packing_list')
162
    self.failIf('Site Error' in packing_list.view())
163
    self.stepCheckPackingListIsDivergent(packing_list=packing_list,sequence=sequence)
Sebastien Robin's avatar
Sebastien Robin committed
164

165 166
  def stepCheckPackingListIsCalculating(self, sequence=None, sequence_list=None, **kw):
    """
167
      Test if packing list is calculating
168 169 170 171 172 173
    """
    packing_list = sequence.get('packing_list')
    self.assertEquals('calculating',packing_list.getCausalityState())

  def stepCheckPackingListIsSolved(self, sequence=None, sequence_list=None, **kw):
    """
174
      Test if packing list is solved
175 176 177 178 179 180 181 182 183
    """
    packing_list = sequence.get('packing_list')
    self.assertEquals('solved',packing_list.getCausalityState())

  def stepCheckPackingListIsDiverged(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is divergent
    """
    packing_list = sequence.get('packing_list')
184
    self.assertEquals('diverged', packing_list.getCausalityState())
185

Sebastien Robin's avatar
Sebastien Robin committed
186 187 188 189 190
  def stepCheckPackingListIsNotDivergent(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is not divergent
    """
    packing_list = sequence.get('packing_list')
191
    self.assertFalse(packing_list.isDivergent())
Sebastien Robin's avatar
Sebastien Robin committed
192

193 194 195 196 197 198 199 200 201 202 203
  def stepChangePackingListLineResource(self, sequence=None, 
                                        sequence_list=None, **kw):
    """
    Change the resource of the packing list.
    """
    packing_list = sequence.get('packing_list')
    resource = sequence.get('resource')
    for packing_list_line in packing_list.objectValues(
                             portal_type=self.packing_list_line_portal_type):
      packing_list_line.edit(resource_value=resource)

204 205
  def stepDecreasePackingListLineQuantity(self, sequence=None,
      sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
206
    """
207
    Set a decreased quantity on packing list lines
Sebastien Robin's avatar
Sebastien Robin committed
208 209
    """
    packing_list = sequence.get('packing_list')
210
    quantity = sequence.get('line_quantity',default=self.default_quantity)
211
    quantity = quantity - 1
212
    sequence.edit(line_quantity=quantity)
Sebastien Robin's avatar
Sebastien Robin committed
213
    for packing_list_line in packing_list.objectValues(
214
        portal_type=self.packing_list_line_portal_type):
215
      packing_list_line.edit(quantity=quantity)
216
    sequence.edit(last_delta = sequence.get('last_delta', 0.0) - 1.0)
Sebastien Robin's avatar
Sebastien Robin committed
217

218 219
  def stepIncreasePackingListLineQuantity(self, sequence=None,
      sequence_list=None, **kw):
220
    """
221
    Set a increased quantity on packing list lines
222 223
    """
    packing_list = sequence.get('packing_list')
224 225 226
    quantity = sequence.get('line_quantity',default=self.default_quantity)
    quantity = quantity + 1
    sequence.edit(line_quantity=quantity)
227
    for packing_list_line in packing_list.objectValues(
228
        portal_type=self.packing_list_line_portal_type):
229 230
      packing_list_line.edit(quantity=quantity)
    sequence.edit(last_delta = sequence.get('last_delta', 0.0) + 1.0)
231

Sebastien Robin's avatar
Sebastien Robin committed
232 233 234 235 236 237 238 239 240 241 242 243
  def stepSplitAndDeferPackingList(self, sequence=None, sequence_list=None, **kw):
    """
      Do the split and defer action
    """
    packing_list = sequence.get('packing_list')
    packing_list.portal_workflow.doActionFor(packing_list,'split_prevision_action',
                                             wf_id='packing_list_causality_workflow',
                                             start_date=self.datetime + 15,
                                             stop_date=self.datetime + 25)

  def stepCheckPackingListSplitted(self, sequence=None, sequence_list=None, **kw):
    """
244
      Test if packing list was splitted
Sebastien Robin's avatar
Sebastien Robin committed
245 246 247 248 249 250 251 252 253 254 255 256
    """
    order = sequence.get('order')
    packing_list_list = order.getCausalityRelatedValueList(
                               portal_type=self.packing_list_portal_type)
    self.assertEquals(2,len(packing_list_list))
    packing_list1 = None
    packing_list2 = None
    for packing_list in packing_list_list:
      if packing_list.getUid() == sequence.get('packing_list').getUid():
        packing_list1 = packing_list
      else:
        packing_list2 = packing_list
257
    sequence.edit(new_packing_list=packing_list2)
Sebastien Robin's avatar
Sebastien Robin committed
258 259 260 261 262 263 264
    for line in packing_list1.objectValues(
          portal_type= self.packing_list_line_portal_type):
      self.assertEquals(self.default_quantity-1,line.getQuantity())
    for line in packing_list2.objectValues(
          portal_type= self.packing_list_line_portal_type):
      self.assertEquals(1,line.getQuantity())

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
  def stepCheckPackingListSplittedTwoTimes(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is divergent
    """
    order = sequence.get('order')
    packing_list_list = order.getCausalityRelatedValueList(
                               portal_type=self.packing_list_portal_type)
    self.assertEquals(2,len(packing_list_list))
    packing_list1 = None
    packing_list2 = None
    for packing_list in packing_list_list:
      if packing_list.getUid() == sequence.get('packing_list').getUid():
        packing_list1 = packing_list
      else:
        packing_list2 = packing_list
    for line in packing_list1.objectValues(
          portal_type= self.packing_list_line_portal_type):
      self.assertEquals(self.default_quantity-2,line.getQuantity())
    for line in packing_list2.objectValues(
          portal_type= self.packing_list_line_portal_type):
      self.assertEquals(2,line.getQuantity())

287 288 289 290 291 292 293 294 295
  def stepCheckPackingListNotSplitted(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is divergent
    """
    order = sequence.get('order')
    packing_list_list = order.getCausalityRelatedValueList(
                               portal_type=self.packing_list_portal_type)
    self.assertEquals(1,len(packing_list_list))
    packing_list1 = sequence.get('packing_list')
296
    last_delta = sequence.get('last_delta', 0.0)
297 298
    for line in packing_list1.objectValues(
          portal_type= self.packing_list_line_portal_type):
299 300
      self.assertEquals(self.default_quantity + last_delta,
          line.getQuantity())
301 302 303 304
      simulation_list = line.getDeliveryRelatedValueList(
                            portal_type='Simulation Movement')
      self.assertEquals(len(simulation_list),1)
      simulation_movement = simulation_list[0]
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
      self.assertEquals(self.default_quantity + last_delta,
          simulation_movement.getCorrectedQuantity())

  def stepCheckPackingListNotSolved(self, sequence=None, sequence_list=None, **kw):
    """
      This step is specific to test_10 : the incorrectly used solver didn't
      solve anything.
    """
    order = sequence.get('order')
    packing_list_list = order.getCausalityRelatedValueList(
                               portal_type=self.packing_list_portal_type)
    self.assertEquals(1,len(packing_list_list))
    packing_list1 = sequence.get('packing_list')
    last_delta = sequence.get('last_delta', 0.0)
    for line in packing_list1.objectValues(
          portal_type= self.packing_list_line_portal_type):
      self.assertEquals(self.default_quantity + last_delta,
          line.getQuantity())
      simulation_list = line.getDeliveryRelatedValueList(
                            portal_type='Simulation Movement')
      self.assertEquals(len(simulation_list),1)
      simulation_movement = simulation_list[0]

      # Here we don't add last_delta, as the solver didn't do its work.
      self.assertEquals(self.default_quantity,
          simulation_movement.getCorrectedQuantity())
331

332 333
  def stepChangePackingListDestination(self, sequence=None, 
                                       sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
334 335 336 337 338
    """
      Test if packing list is divergent
    """
    organisation3 = sequence.get('organisation3')
    packing_list = sequence.get('packing_list')
339
    packing_list.edit(destination_value=organisation3)
Sebastien Robin's avatar
Sebastien Robin committed
340 341 342 343 344 345 346 347 348 349 350 351

  def stepCreateOrganisation3(self,sequence=None, sequence_list=None, **kw):
    """
      Create a empty organisation
    """
    self.stepCreateOrganisation(sequence=sequence, sequence_list=sequence_list,
                                **kw)
    organisation = sequence.get('organisation')
    sequence.edit(organisation3=organisation)

  def stepCheckSimulationDestinationUpdated(self,sequence=None, sequence_list=None, **kw):
    """
Alexandre Boeglin's avatar
Alexandre Boeglin committed
352
      Test if the destination of the simulation movement was changed
Sebastien Robin's avatar
Sebastien Robin committed
353 354 355 356 357 358 359 360 361 362
    """
    applied_rule = sequence.get('applied_rule')
    simulation_line_list = applied_rule.objectValues()
    self.assertEquals(len(simulation_line_list),1)
    org3 = sequence.get('organisation3')
    for simulation_line in simulation_line_list:
      self.assertEquals(simulation_line.getDestinationValue(),org3)

  def stepChangePackingListStartDate(self, sequence=None, sequence_list=None, **kw):
    """
Alexandre Boeglin's avatar
Alexandre Boeglin committed
363
      Change the start_date of the packing_list.
Sebastien Robin's avatar
Sebastien Robin committed
364 365
    """
    packing_list = sequence.get('packing_list')
366
    packing_list.edit(start_date=self.datetime + 15)
Sebastien Robin's avatar
Sebastien Robin committed
367 368 369

  def stepCheckSimulationStartDateUpdated(self,sequence=None, sequence_list=None, **kw):
    """
Alexandre Boeglin's avatar
Alexandre Boeglin committed
370
      Test if the start_date of the simulation movement was changed
Sebastien Robin's avatar
Sebastien Robin committed
371 372 373 374 375 376 377
    """
    applied_rule = sequence.get('applied_rule')
    simulation_line_list = applied_rule.objectValues()
    self.assertEquals(len(simulation_line_list),1)
    for simulation_line in simulation_line_list:
      self.assertEquals(simulation_line.getStartDate(),self.datetime + 15)

378 379 380 381 382 383 384
  def stepEditPackingListLine(self,sequence=None, sequence_list=None, **kw):
    """
      Edits a Packing List Line
    """
    packing_list_line = sequence.get('packing_list_line')
    packing_list_line.edit(description='This line was edited!')

Sebastien Robin's avatar
Sebastien Robin committed
385 386
  def stepDeletePackingListLine(self,sequence=None, sequence_list=None, **kw):
    """
387
      Deletes a Packing List Line
Sebastien Robin's avatar
Sebastien Robin committed
388 389 390 391 392
    """
    packing_list = sequence.get('packing_list')
    packing_list_line_id = sequence.get('packing_list_line').getId()
    packing_list.manage_delObjects([packing_list_line_id])

393 394 395 396 397 398 399 400 401 402 403 404 405
  def stepAddPackingListLine(self,sequence=None, sequence_list=None, **kw):
    """
      Adds a Packing List Line
    """
    packing_list = sequence.get('packing_list')
    packing_list_line = packing_list.newContent(
        portal_type=self.packing_list_line_portal_type)
    self.stepCreateNotVariatedResource(sequence=sequence,
        sequence_list=sequence_list, **kw)
    resource = sequence.get('resource')
    packing_list_line.setResourceValue(resource)
    packing_list_line.edit(price=100, quantity=200)

Sebastien Robin's avatar
Sebastien Robin committed
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
  def stepCheckSimulationConnected(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    applied_rule = sequence.get('applied_rule')
    simulation_line_list = applied_rule.objectValues()
    self.assertEquals(len(simulation_line_list),1)
    packing_list = sequence.get('packing_list')
    packing_list_line = sequence.get('packing_list_line')
    for simulation_line in simulation_line_list:
      self.assertEquals(simulation_line.getDeliveryValue(),packing_list_line)

  def stepCheckSimulationDisconnected(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    applied_rule = sequence.get('applied_rule')
    simulation_line_list = applied_rule.objectValues()
    self.assertEquals(len(simulation_line_list),1)
    for simulation_line in simulation_line_list:
      self.assertEquals(simulation_line.getDeliveryValue(),None)

  def stepModifySimulationLineQuantity(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    applied_rule = sequence.get('applied_rule')
    simulation_line_list = applied_rule.objectValues()
    self.assertEquals(len(simulation_line_list),1)
    for simulation_line in simulation_line_list:
436
      simulation_line.edit(quantity=self.default_quantity-1)
Sebastien Robin's avatar
Sebastien Robin committed
437 438 439 440 441 442 443

  def stepModifySimulationLineStartDate(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    applied_rule = sequence.get('applied_rule')
    simulation_line_list = applied_rule.objectValues()
444 445
    resource_list = sequence.get('resource_list')
    self.assertEquals(len(simulation_line_list),len(resource_list))
Sebastien Robin's avatar
Sebastien Robin committed
446
    for simulation_line in simulation_line_list:
447
      simulation_line.edit(start_date=self.datetime+15)
Sebastien Robin's avatar
Sebastien Robin committed
448

449 450
  def stepAdoptPrevision(self,sequence=None, sequence_list=None, 
                         packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
451 452 453
    """
      Check if simulation movement are disconnected
    """
454 455
    if packing_list is None:
      packing_list = sequence.get('packing_list')
456 457
    LOG('packing_list.getSimulationState()',0,packing_list.getSimulationState())
    LOG('packing_list.getCausalityState()',0,packing_list.getCausalityState())
Sebastien Robin's avatar
Sebastien Robin committed
458 459
    packing_list.portal_workflow.doActionFor(packing_list,'adopt_prevision_action')

460 461 462 463 464 465 466
  def stepNewPackingListAdoptPrevision(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    packing_list = sequence.get('new_packing_list')
    self.stepAdoptPrevision(sequence=sequence,packing_list=packing_list)

467
  def stepAcceptDecisionPackingList(self,sequence=None, sequence_list=None, **kw):
468 469 470 471 472 473
    """
      Check if simulation movement are disconnected
    """
    packing_list = sequence.get('packing_list')
    packing_list.portal_workflow.doActionFor(packing_list,'accept_decision_action')

Sebastien Robin's avatar
Sebastien Robin committed
474 475 476 477 478 479 480 481 482 483 484 485 486
  def stepCheckPackingListLineWithNewQuantityPrevision(self,sequence=None, sequence_list=None, **kw):
    """
      Look if the packing list has new previsions
    """
    packing_list_line = sequence.get('packing_list_line')
    self.assertEquals(packing_list_line.getQuantity(),self.default_quantity-1)

  def stepCheckNewPackingListAfterStartDateAdopt(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    applied_rule = sequence.get('applied_rule')
    packing_list_line = sequence.get('packing_list_line')
487 488 489
    packing_list = sequence.get('packing_list')
    LOG('CheckNewPackingList, self.datetime+15',0,self.datetime+15)
    LOG('CheckNewPackingList, packing_list.getStartDate',0,packing_list.getStartDate())
490 491
    self.assertEquals(packing_list_line.getQuantity(),self.default_quantity)
    self.assertEquals(packing_list.getStartDate(),self.datetime+15)
Sebastien Robin's avatar
Sebastien Robin committed
492
    simulation_line_list = applied_rule.objectValues()
493 494 495
    resource_list = sequence.get('resource_list')
    self.assertEquals(len(simulation_line_list),len(resource_list))
    delivery_value_list = []
Sebastien Robin's avatar
Sebastien Robin committed
496
    for simulation_line in simulation_line_list:
497
#      self.assertNotEquals(simulation_line.getDeliveryValue(),None)
498
      delivery_value = simulation_line.getDeliveryValue()
499 500 501 502 503
      if delivery_value not in delivery_value_list:
        delivery_value_list.append(delivery_value_list)
#      new_packing_list = delivery_value.getParent()
#      self.assertNotEquals(new_packing_list.getUid(),packing_list.getUid())
    self.assertEquals(len(delivery_value_list),len(resource_list))
Sebastien Robin's avatar
Sebastien Robin committed
504

505 506
  def stepAddPackingListContainer(self,sequence=None, 
                                  packing_list=None,sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
507 508 509
    """
      Check if simulation movement are disconnected
    """
510 511
    if packing_list is None:
      packing_list = sequence.get('packing_list')
512
    container = packing_list.newContent(portal_type=self.container_portal_type)
Sebastien Robin's avatar
Sebastien Robin committed
513 514
    sequence.edit(container=container)

515 516 517 518 519 520 521 522 523
  def stepDefineNewPackingListContainer(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    packing_list = sequence.get('new_packing_list')
    self.stepAddPackingListContainer(sequence=sequence,packing_list=packing_list)
    self.stepAddPackingListContainerLine(sequence=sequence)
    self.stepSetContainerLineFullQuantity(quantity=1,sequence=sequence)

Sebastien Robin's avatar
Sebastien Robin committed
524 525 526 527 528
  def stepAddPackingListContainerLine(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    container = sequence.get('container')
529
    container_line = container.newContent(portal_type=self.container_line_portal_type)
Sebastien Robin's avatar
Sebastien Robin committed
530 531
    sequence.edit(container_line=container_line)
    resource = sequence.get('resource')
532
    container_line.edit(resource_value=resource)
Sebastien Robin's avatar
Sebastien Robin committed
533 534 535 536 537 538 539 540

  def stepSetContainerLineSmallQuantity(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    container_line = sequence.get('container_line')
    container_line.edit(quantity=self.default_quantity-1)

541 542
  def stepSetContainerLineFullQuantity(self,sequence=None, sequence_list=None, 
                                       quantity=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
543 544 545 546
    """
      Check if simulation movement are disconnected
    """
    container_line = sequence.get('container_line')
547 548 549
    if quantity is None:
      quantity = sequence.get('line_quantity',self.default_quantity)
    container_line.edit(quantity=quantity)
550
    container_line.immediateReindexObject()
Sebastien Robin's avatar
Sebastien Robin committed
551

552 553 554 555 556 557 558 559 560 561 562 563 564 565
  def stepSetContainerFullQuantity(self,sequence=None, sequence_list=None, 
                                       quantity=None,**kw):
    """
      Really fills the container
    """
    packing_list = sequence.get('packing_list')
    container = sequence.get('container')
    #empty container
    container.deleteContent(container.contentIds())
    for line in packing_list.objectValues(
        portal_type=self.packing_list_line_portal_type):
      resource = line.getResourceValue()
      tmp_kw={'movement.resource_uid':resource.getUid()}
      container_line = \
566
          container.newContent(portal_type=self.container_line_portal_type)
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
      container_line.setResourceValue(resource)
      # without variation
      if not line.hasCellContent():
        quantity = line.getQuantity()
        container_line.edit(quantity=quantity)
        container_line.immediateReindexObject()
      # with variation
      elif line.hasCellContent():
        vcl = line.getVariationCategoryList()
        vcl.sort()
        base_id = 'movement'
        container_line.setVariationCategoryList(vcl)
        cell_key_list = list(line.getCellKeyList(base_id=base_id))
        cell_key_list.sort()
        for cell_key in cell_key_list:
          if line.hasCell(base_id=base_id, *cell_key):
            old_cell = line.getCell(base_id=base_id, *cell_key)
            cell = container_line.newCell(base_id=base_id,
585
                portal_type=self.container_cell_portal_type, *cell_key)
586 587 588 589 590 591 592
            cell.edit(mapped_value_property_list=['price', 'quantity'],
                price=old_cell.getPrice(),
                quantity=old_cell.getQuantity(),
                predicate_category_list=cell_key,
                variation_category_list=cell_key)
            cell.immediateReindexObject()

Sebastien Robin's avatar
Sebastien Robin committed
593 594 595 596 597 598
  def stepCheckPackingListIsNotPacked(self,sequence=None, sequence_list=None, **kw):
    """
      Check that the number of objects in containers are
      not equals to the quantity of the packing list
    """
    packing_list = sequence.get('packing_list')
599 600
    if packing_list.getPortalType() not in \
        self.packable_packing_list_portal_type_list: return
Sebastien Robin's avatar
Sebastien Robin committed
601
    self.assertEquals(0,packing_list.isPacked())
602
    self.assertEquals('missing',packing_list.getContainerState())
Sebastien Robin's avatar
Sebastien Robin committed
603

604 605
  def stepCheckPackingListIsPacked(self,sequence=None, sequence_list=None, 
                                   packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
606 607 608 609
    """
      Check that the number of objects in containers are
      equals to the quantity of the packing list
    """
610 611
    if packing_list is None:
      packing_list = sequence.get('packing_list')
612 613
    if packing_list.getPortalType() not in \
        self.packable_packing_list_portal_type_list: return
614
    get_transaction().commit()
Sebastien Robin's avatar
Sebastien Robin committed
615
    self.assertEquals(1,packing_list.isPacked())
616
    self.assertEquals('packed',packing_list.getContainerState())
Sebastien Robin's avatar
Sebastien Robin committed
617

618 619 620 621 622 623
  def stepCheckNewPackingListIsPacked(self,sequence=None, sequence_list=None, **kw):
    """
      Check that the number of objects in containers are
      equals to the quantity of the packing list
    """
    packing_list = sequence.get('new_packing_list')
624 625
    if packing_list.getPortalType() not in \
        self.packable_packing_list_portal_type_list: return
626 627 628
    self.stepCheckPackingListIsPacked(sequence=sequence,
                                      packing_list=packing_list)

629 630

class TestPackingList(TestPackingListMixin, ERP5TypeTestCase) :
631

632
  run_all_test = 1
633 634 635
  quiet = 0

  def test_01_PackingListDecreaseQuantity(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
636 637 638
    """
      Change the quantity on an delivery line, then
      see if the packing list is divergent and then
639
      split and defer the packing list
Sebastien Robin's avatar
Sebastien Robin committed
640 641 642 643 644 645
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
646 647 648 649 650 651
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
Sebastien Robin's avatar
Sebastien Robin committed
652 653 654
                      '
    sequence_list.addSequenceString(sequence_string)

655
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
656

657
  def test_02_PackingListChangeDestination(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
658 659 660 661 662 663 664 665
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
666
                      stepChangePackingListDestination \
667 668
                      stepCheckPackingListIsCalculating \
                      stepAcceptDecisionPackingList \
669
                      stepTic \
670 671
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListIsNotDivergent \
672
                      stepCheckSimulationDestinationUpdated \
Sebastien Robin's avatar
Sebastien Robin committed
673 674 675
                      '
    sequence_list.addSequenceString(sequence_string)

676
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
677

678
  def test_03_PackingListChangeStartDate(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
679 680 681 682 683 684 685 686
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
687 688
                      stepChangePackingListStartDate \
                      stepCheckPackingListIsCalculating \
689
                      stepAcceptDecisionPackingList \
690 691 692 693
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckSimulationStartDateUpdated \
Sebastien Robin's avatar
Sebastien Robin committed
694 695 696
                      '
    sequence_list.addSequenceString(sequence_string)

697
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
698

699
  def test_04_PackingListDeleteLine(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
700 701 702 703 704 705 706 707
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
708 709 710 711 712
                      stepCheckSimulationConnected \
                      stepDeletePackingListLine \
                      stepCheckPackingListIsNotDivergent \
                      stepTic \
                      stepCheckSimulationDisconnected \
Sebastien Robin's avatar
Sebastien Robin committed
713 714 715
                      '
    sequence_list.addSequenceString(sequence_string)

716
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
717

718
  def test_05_SimulationChangeQuantity(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
719 720 721 722 723 724 725 726
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
727 728 729 730 731 732 733 734
                      stepModifySimulationLineQuantity \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListLineWithNewQuantityPrevision \
Sebastien Robin's avatar
Sebastien Robin committed
735 736 737
                      '
    sequence_list.addSequenceString(sequence_string)

738
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
739

740
  def test_06_SimulationChangeStartDate(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
741 742 743 744 745 746 747 748
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
749 750 751 752 753 754 755
                      stepModifySimulationLineStartDate \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckNewPackingListAfterStartDateAdopt \
Sebastien Robin's avatar
Sebastien Robin committed
756
                      '
757
    # XXX Check if there is a new packing list created
Sebastien Robin's avatar
Sebastien Robin committed
758 759
    sequence_list.addSequenceString(sequence_string)

760
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
761

762
  def test_07_SimulationChangeStartDateWithTwoOrderLine(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
763 764 765 766 767 768 769
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
770
    sequence_string = self.default_sequence_with_two_lines + '\
771 772 773 774 775 776 777 778 779
                      stepModifySimulationLineStartDate \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepCheckPackingListIsDivergent \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckNewPackingListAfterStartDateAdopt \
Sebastien Robin's avatar
Sebastien Robin committed
780 781 782 783
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)

784
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
785

786
  def test_08_AddContainers(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
787 788 789 790 791 792 793 794
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
795 796 797 798 799 800 801
                      stepAddPackingListContainer \
                      stepAddPackingListContainerLine \
                      stepSetContainerLineSmallQuantity \
                      stepCheckPackingListIsNotPacked \
                      stepSetContainerFullQuantity \
                      stepTic \
                      stepCheckPackingListIsPacked \
Sebastien Robin's avatar
Sebastien Robin committed
802 803 804 805
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)

806
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
807

808
  def test_09_AddContainersWithVariatedResources(self, quiet=quiet, run=run_all_test):
809 810 811 812 813 814
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

815 816
    # Test with a order with cells
    sequence_string = self.variated_default_sequence + '\
817 818 819 820 821 822 823
                      stepAddPackingListContainer \
                      stepAddPackingListContainerLine \
                      stepSetContainerLineSmallQuantity \
                      stepCheckPackingListIsNotPacked \
                      stepSetContainerFullQuantity \
                      stepTic \
                      stepCheckPackingListIsPacked \
824 825 826
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)
827
    
828
    sequence_list.play(self, quiet=quiet)
829

830
  def test_10_PackingListIncreaseQuantity(self, quiet=quiet, run=run_all_test):
831
    """
832 833 834 835 836 837 838 839
    - Increase the quantity on an delivery line
    - check if the packing list is divergent
    - Apply the "split and defer" solver to the packing list
    - check that nothing was splitted and the packing list is still divergent
      (reset the delta before, as we don't expect a modification)

    Basically, when we apply "split and defer" to a packing list, we don't
    want it to modify lines which have been increased.
840 841 842 843 844 845
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
846 847 848 849
                      stepIncreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
850 851 852
                      stepCheckPackingListIsDiverged \
                      stepCheckPackingListIsDivergent \
                      stepCheckPackingListNotSolved \
853 854 855
                      '
    sequence_list.addSequenceString(sequence_string)

856
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
857

858 859
  def test_11_PackingListDecreaseTwoTimesQuantityAndUpdateDelivery(self,
                                               quiet=quiet, run=run_all_test):
860 861 862 863 864 865 866 867 868 869
    """
      Change the quantity on an delivery line, then
      see if the packing list is divergent and then
      split and defer the packing list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckNewPackingListIsDivergent \
                      stepNewPackingListAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplittedTwoTimes \
885 886 887
                      '
    sequence_list.addSequenceString(sequence_string)

888
    sequence_list.play(self, quiet=quiet)
889

890
  def test_12_PackingListLineChangeResource(self, quiet=quiet, run=run_all_test):
891 892 893 894 895 896 897 898
    """
    Test if delivery diverged when we change the resource.
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
899 900 901 902 903
                      stepCreateNotVariatedResource \
                      stepChangePackingListLineResource \
                      stepCheckPackingListIsCalculating \
                      stepTic \
                      stepCheckPackingListIsDivergent \
904 905 906
                      '
    sequence_list.addSequenceString(sequence_string)

907
    sequence_list.play(self, quiet=quiet)
908

909
  def test_14_PackingListHavePriceCurrencyCategory(self, quiet=quiet,
910
                                                   run=run_all_test):
911 912 913 914
    """Deliveries must have a price currency category. #252
    """
    if not run:
      return
915 916 917 918
    pl = self.getPortal().getDefaultModule(self.packing_list_portal_type
               ).newContent(portal_type=self.packing_list_portal_type)
    self.failUnless(hasattr(pl, 'getPriceCurrency'))
    
Sebastien Robin's avatar
Sebastien Robin committed
919 920 921 922 923 924
if __name__ == '__main__':
    framework()
else:
    import unittest
    def test_suite():
        suite = unittest.TestSuite()
925
        suite.addTest(unittest.makeSuite(TestPackingList))
Sebastien Robin's avatar
Sebastien Robin committed
926 927
        return suite