testPackingList.py 36 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
  def test_01_PackingListDecreaseQuantity(self, quiet=0, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
634 635 636
    """
      Change the quantity on an delivery line, then
      see if the packing list is divergent and then
637
      split and defer the packing list
Sebastien Robin's avatar
Sebastien Robin committed
638 639 640 641 642 643
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
644 645 646 647 648 649
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
Sebastien Robin's avatar
Sebastien Robin committed
650 651 652 653 654 655 656 657 658 659 660 661 662 663
                      '
    sequence_list.addSequenceString(sequence_string)

    sequence_list.play(self)

  def test_02_PackingListChangeDestination(self, quiet=0, run=run_all_test):
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
664
                      stepChangePackingListDestination \
665 666
                      stepCheckPackingListIsCalculating \
                      stepAcceptDecisionPackingList \
667
                      stepTic \
668 669
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListIsNotDivergent \
670
                      stepCheckSimulationDestinationUpdated \
Sebastien Robin's avatar
Sebastien Robin committed
671 672 673 674 675 676 677 678 679 680 681 682 683 684
                      '
    sequence_list.addSequenceString(sequence_string)

    sequence_list.play(self)

  def test_03_PackingListChangeStartDate(self, quiet=0, run=run_all_test):
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

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

    sequence_list.play(self)

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

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

    sequence_list.play(self)

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

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

    sequence_list.play(self)

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

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

    sequence_list.play(self)

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

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

    sequence_list.play(self)

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

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

    sequence_list.play(self)

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

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

828 829
  def test_10_PackingListIncreaseQuantity(self, quiet=0, run=run_all_test):
    """
830 831 832 833 834 835 836 837
    - 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.
838 839 840 841 842 843
    """
    if not run: return
    sequence_list = SequenceList()

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

    sequence_list.play(self)
Sebastien Robin's avatar
Sebastien Robin committed
855

856 857 858 859 860 861 862 863 864 865 866 867
  def test_11_PackingListDecreaseTwoTimesQuantityAndUpdateDelivery(self, 
                                               quiet=0, run=run_all_test):
    """
      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 + '\
868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckNewPackingListIsDivergent \
                      stepNewPackingListAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplittedTwoTimes \
883 884 885 886 887
                      '
    sequence_list.addSequenceString(sequence_string)

    sequence_list.play(self)

888 889 890 891 892 893 894 895 896
  def test_12_PackingListLineChangeResource(self, quiet=0, run=run_all_test):
    """
    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 + '\
897 898 899 900 901
                      stepCreateNotVariatedResource \
                      stepChangePackingListLineResource \
                      stepCheckPackingListIsCalculating \
                      stepTic \
                      stepCheckPackingListIsDivergent \
902 903 904 905 906
                      '
    sequence_list.addSequenceString(sequence_string)

    sequence_list.play(self)

907

Sebastien Robin's avatar
Sebastien Robin committed
908 909 910 911 912 913
if __name__ == '__main__':
    framework()
else:
    import unittest
    def test_suite():
        suite = unittest.TestSuite()
914
        suite.addTest(unittest.makeSuite(TestPackingList))
Sebastien Robin's avatar
Sebastien Robin committed
915 916
        return suite