testPackingList.py 44.7 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, 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.
#
##############################################################################

29
import unittest
Sebastien Robin's avatar
Sebastien Robin committed
30 31 32

from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
from zLOG import LOG
33
from Products.ERP5Type.tests.Sequence import SequenceList
34
from testOrder import TestOrderMixin
Sebastien Robin's avatar
Sebastien Robin committed
35

36
class TestPackingListMixin(TestOrderMixin):
Sebastien Robin's avatar
Sebastien Robin committed
37 38 39
  """
    Test business template erp5_trade 
  """
40 41 42 43
  container_portal_type = 'Container'
  container_line_portal_type = 'Container Line'
  container_cell_portal_type = 'Container Cell'

44 45
  default_order_sequence = '\
                      stepCreateOrganisation1 \
46 47 48
                      stepCreateOrganisation2 \
                      stepCreateOrganisation3 \
                      stepCreateOrder \
49 50
                      stepCreateCurrency \
                      stepSetOrderPriceCurrency \
51 52 53
                      stepSetOrderProfile '

  default_sequence = default_order_sequence + '\
54 55 56 57 58 59 60 61 62 63 64
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
65 66
                      stepCheckPackingListIsNotDivergent \
                      stepCheckOrderPackingList '
67

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
  default_sequence_with_duplicated_lines = default_order_sequence + '\
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckOrderPackingList '

  default_sequence_with_two_lines = default_order_sequence + '\
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
104 105
                      stepCheckPackingListIsNotDivergent \
                      stepCheckOrderPackingList'
106

107
  variated_default_sequence = default_order_sequence + '\
108 109 110 111 112 113 114 115 116 117 118 119 120
                      stepCreateVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepSetOrderLineFullVCL \
                      stepCompleteOrderLineMatrix \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
121 122
                      stepCheckPackingListIsNotDivergent \
                      stepCheckOrderPackingList'
123

Sebastien Robin's avatar
Sebastien Robin committed
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
  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

141 142 143 144 145 146 147 148 149 150
  def stepCheckOrderPackingList(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is matching order
    """
    packing_list = sequence.get('packing_list')
    order = sequence.get('order')
    self.assertEquals(packing_list.getCausalityValue(), order)
    self.assertEquals(packing_list.getSource(), order.getSource())
    self.assertEquals(packing_list.getDestination(), order.getDestination())
    self.assertEquals(packing_list.getDestinationSection(), \
Jérome Perrin's avatar
Jérome Perrin committed
151
                                       order.getDestinationSection())
152 153 154 155 156 157 158 159
    self.assertEquals(packing_list.getSourceSection(), \
                                       order.getSourceSection())
    self.assertEquals(packing_list.getSourceDecision(), \
                                       order.getSourceDecision())
    self.assertEquals(packing_list.getDestinationAdministration(), \
                                       order.getDestinationAdministration())
    self.assertEquals(packing_list.getSourceAdministration(), \
                                       order.getSourceAdministration())
160 161
    self.assertEquals(packing_list.getPriceCurrency(), \
                                       order.getPriceCurrency())
162

163 164
  def stepCheckPackingListIsDivergent(self, sequence=None, sequence_list=None, 
                                      packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
165 166 167
    """
      Test if packing list is divergent
    """
168 169
    if packing_list is None:
      packing_list = sequence.get('packing_list')
170 171
    self.failIf('Site Error' in packing_list.view())
    self.assertTrue(packing_list.isDivergent())
172 173 174 175 176 177

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

181 182
  def stepCheckPackingListIsCalculating(self, sequence=None, sequence_list=None, **kw):
    """
183
      Test if packing list is calculating
184 185 186 187 188 189
    """
    packing_list = sequence.get('packing_list')
    self.assertEquals('calculating',packing_list.getCausalityState())

  def stepCheckPackingListIsSolved(self, sequence=None, sequence_list=None, **kw):
    """
190
      Test if packing list is solved
191 192 193 194 195 196 197 198 199
    """
    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')
200
    self.assertEquals('diverged', packing_list.getCausalityState())
201

Sebastien Robin's avatar
Sebastien Robin committed
202 203 204 205 206
  def stepCheckPackingListIsNotDivergent(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is not divergent
    """
    packing_list = sequence.get('packing_list')
207
    self.assertFalse(packing_list.isDivergent())
Sebastien Robin's avatar
Sebastien Robin committed
208

209 210 211 212 213 214 215 216 217 218 219
  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)

220 221
  def stepDecreasePackingListLineQuantity(self, sequence=None,
      sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
222
    """
223
    Set a decreased quantity on packing list lines
Sebastien Robin's avatar
Sebastien Robin committed
224 225
    """
    packing_list = sequence.get('packing_list')
226
    quantity = sequence.get('line_quantity',default=self.default_quantity)
227
    quantity = quantity - 1
228
    sequence.edit(line_quantity=quantity)
Sebastien Robin's avatar
Sebastien Robin committed
229
    for packing_list_line in packing_list.objectValues(
230
        portal_type=self.packing_list_line_portal_type):
231
      packing_list_line.edit(quantity=quantity)
232
    sequence.edit(last_delta = sequence.get('last_delta', 0.0) - 1.0)
Sebastien Robin's avatar
Sebastien Robin committed
233

234 235
  def stepIncreasePackingListLineQuantity(self, sequence=None,
      sequence_list=None, **kw):
236
    """
237
    Set a increased quantity on packing list lines
238 239
    """
    packing_list = sequence.get('packing_list')
240 241 242
    quantity = sequence.get('line_quantity',default=self.default_quantity)
    quantity = quantity + 1
    sequence.edit(line_quantity=quantity)
243
    for packing_list_line in packing_list.objectValues(
244
        portal_type=self.packing_list_line_portal_type):
245 246
      packing_list_line.edit(quantity=quantity)
    sequence.edit(last_delta = sequence.get('last_delta', 0.0) + 1.0)
247

Sebastien Robin's avatar
Sebastien Robin committed
248 249 250 251 252 253 254 255 256 257 258
  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',
                                             start_date=self.datetime + 15,
                                             stop_date=self.datetime + 25)

  def stepCheckPackingListSplitted(self, sequence=None, sequence_list=None, **kw):
    """
259
      Test if packing list was splitted
Sebastien Robin's avatar
Sebastien Robin committed
260 261 262 263 264 265 266 267 268 269 270 271
    """
    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
272
    sequence.edit(new_packing_list=packing_list2)
Sebastien Robin's avatar
Sebastien Robin committed
273 274 275 276 277 278 279
    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())

280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
  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())

302 303 304 305 306 307 308 309 310
  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')
311
    last_delta = sequence.get('last_delta', 0.0)
312 313
    for line in packing_list1.objectValues(
          portal_type= self.packing_list_line_portal_type):
314 315
      self.assertEquals(self.default_quantity + last_delta,
          line.getQuantity())
316 317 318 319
      simulation_list = line.getDeliveryRelatedValueList(
                            portal_type='Simulation Movement')
      self.assertEquals(len(simulation_list),1)
      simulation_movement = simulation_list[0]
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
      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())
346

347 348
  def stepChangePackingListDestination(self, sequence=None, 
                                       sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
349 350 351 352 353
    """
      Test if packing list is divergent
    """
    organisation3 = sequence.get('organisation3')
    packing_list = sequence.get('packing_list')
354
    packing_list.edit(destination_value=organisation3)
Sebastien Robin's avatar
Sebastien Robin committed
355 356 357 358 359 360 361 362 363 364 365 366

  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
367
      Test if the destination of the simulation movement was changed
Sebastien Robin's avatar
Sebastien Robin committed
368 369 370 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)
    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
378
      Change the start_date of the packing_list.
Sebastien Robin's avatar
Sebastien Robin committed
379 380
    """
    packing_list = sequence.get('packing_list')
381
    packing_list.edit(start_date=self.datetime + 15)
Sebastien Robin's avatar
Sebastien Robin committed
382 383 384

  def stepCheckSimulationStartDateUpdated(self,sequence=None, sequence_list=None, **kw):
    """
Alexandre Boeglin's avatar
Alexandre Boeglin committed
385
      Test if the start_date of the simulation movement was changed
Sebastien Robin's avatar
Sebastien Robin committed
386 387 388 389 390 391 392
    """
    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)

393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
  def stepCheckSimulationQuantityUpdated(self,sequence=None, sequence_list=None, **kw):
    """
      Test if the quantity of the simulation movement was changed
    """
    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.getQuantity() + \
                        simulation_line.getDeliveryError(),
                        self.default_quantity)

  def stepCheckSimulationQuantityUpdatedForMergedLine(self,sequence=None, sequence_list=None, **kw):
    """
      Test if the quantity of the simulation movement was changed
    """
    applied_rule = sequence.get('applied_rule')
    simulation_line_list = applied_rule.objectValues()
    self.assertEquals(len(simulation_line_list),2)
    for simulation_line in simulation_line_list:
      self.assertEquals(simulation_line.getQuantity() + \
                        simulation_line.getDeliveryError(),
                        self.default_quantity)

417 418 419 420 421 422 423
  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
424 425
  def stepDeletePackingListLine(self,sequence=None, sequence_list=None, **kw):
    """
426
      Deletes a Packing List Line
Sebastien Robin's avatar
Sebastien Robin committed
427 428 429 430 431
    """
    packing_list = sequence.get('packing_list')
    packing_list_line_id = sequence.get('packing_list_line').getId()
    packing_list.manage_delObjects([packing_list_line_id])

432 433 434 435 436 437 438 439 440 441 442 443 444
  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
445 446
  def stepCheckSimulationConnected(self,sequence=None, sequence_list=None, **kw):
    """
447
      Check if simulation movement are connected
Sebastien Robin's avatar
Sebastien Robin committed
448 449 450 451 452 453 454 455
    """
    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)
456 457
      self.assertEquals(packing_list_line.getCausalityValue(), 
                        simulation_line.getOrderValue())
Sebastien Robin's avatar
Sebastien Robin committed
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476

  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:
477
      simulation_line.edit(quantity=self.default_quantity-1)
Sebastien Robin's avatar
Sebastien Robin committed
478

479 480 481 482 483 484 485 486 487 488
  def stepModifySimulationLineQuantityForMergedLine(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),2)
    for simulation_line in simulation_line_list:
      simulation_line.edit(quantity=self.default_quantity-1)

Sebastien Robin's avatar
Sebastien Robin committed
489 490 491 492 493 494
  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()
495 496
    resource_list = sequence.get('resource_list')
    self.assertEquals(len(simulation_line_list),len(resource_list))
Sebastien Robin's avatar
Sebastien Robin committed
497
    for simulation_line in simulation_line_list:
498
      simulation_line.edit(start_date=self.datetime+15)
Sebastien Robin's avatar
Sebastien Robin committed
499

500 501
  def stepAdoptPrevision(self,sequence=None, sequence_list=None, 
                         packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
502 503 504
    """
      Check if simulation movement are disconnected
    """
505 506
    if packing_list is None:
      packing_list = sequence.get('packing_list')
507 508
    LOG('packing_list.getSimulationState()',0,packing_list.getSimulationState())
    LOG('packing_list.getCausalityState()',0,packing_list.getCausalityState())
Sebastien Robin's avatar
Sebastien Robin committed
509 510
    packing_list.portal_workflow.doActionFor(packing_list,'adopt_prevision_action')

511 512 513 514 515 516 517
  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)

518
  def stepAcceptDecisionPackingList(self,sequence=None, sequence_list=None, **kw):
519 520 521 522 523 524
    """
      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
525 526 527 528 529 530 531
  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)

532 533 534 535 536 537 538
  def stepCheckPackingListLineWithNewQuantityPrevisionForMergedLine(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)*2)

Sebastien Robin's avatar
Sebastien Robin committed
539 540 541 542 543 544
  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')
545 546 547
    packing_list = sequence.get('packing_list')
    LOG('CheckNewPackingList, self.datetime+15',0,self.datetime+15)
    LOG('CheckNewPackingList, packing_list.getStartDate',0,packing_list.getStartDate())
548 549
    self.assertEquals(packing_list_line.getQuantity(),self.default_quantity)
    self.assertEquals(packing_list.getStartDate(),self.datetime+15)
Sebastien Robin's avatar
Sebastien Robin committed
550
    simulation_line_list = applied_rule.objectValues()
551 552 553
    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
554
    for simulation_line in simulation_line_list:
555
#      self.assertNotEquals(simulation_line.getDeliveryValue(),None)
556
      delivery_value = simulation_line.getDeliveryValue()
557 558 559 560 561
      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
562

563 564
  def stepAddPackingListContainer(self,sequence=None, 
                                  packing_list=None,sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
565 566 567
    """
      Check if simulation movement are disconnected
    """
568 569
    if packing_list is None:
      packing_list = sequence.get('packing_list')
570
    container = packing_list.newContent(portal_type=self.container_portal_type)
Sebastien Robin's avatar
Sebastien Robin committed
571 572
    sequence.edit(container=container)

573 574 575 576 577 578 579 580 581
  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
582 583 584 585 586
  def stepAddPackingListContainerLine(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    container = sequence.get('container')
587
    container_line = container.newContent(portal_type=self.container_line_portal_type)
Sebastien Robin's avatar
Sebastien Robin committed
588 589
    sequence.edit(container_line=container_line)
    resource = sequence.get('resource')
590
    container_line.edit(resource_value=resource)
Sebastien Robin's avatar
Sebastien Robin committed
591 592 593 594 595 596 597 598

  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)

599 600
  def stepSetContainerLineFullQuantity(self,sequence=None, sequence_list=None, 
                                       quantity=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
601 602 603 604
    """
      Check if simulation movement are disconnected
    """
    container_line = sequence.get('container_line')
605 606 607
    if quantity is None:
      quantity = sequence.get('line_quantity',self.default_quantity)
    container_line.edit(quantity=quantity)
608
    container_line.immediateReindexObject()
Sebastien Robin's avatar
Sebastien Robin committed
609

610 611 612 613 614 615 616 617 618 619 620 621 622 623
  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 = \
624
          container.newContent(portal_type=self.container_line_portal_type)
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
      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,
643
                portal_type=self.container_cell_portal_type, *cell_key)
644 645 646 647 648 649 650
            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
651 652 653 654 655 656 657
  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')
    self.assertEquals(0,packing_list.isPacked())
658
    self.assertEquals('missing',packing_list.getContainerState())
Sebastien Robin's avatar
Sebastien Robin committed
659

660 661
  def stepCheckPackingListIsPacked(self,sequence=None, sequence_list=None, 
                                   packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
662 663 664 665
    """
      Check that the number of objects in containers are
      equals to the quantity of the packing list
    """
666 667
    if packing_list is None:
      packing_list = sequence.get('packing_list')
668
    get_transaction().commit()
Sebastien Robin's avatar
Sebastien Robin committed
669
    self.assertEquals(1,packing_list.isPacked())
670
    self.assertEquals('packed',packing_list.getContainerState())
Sebastien Robin's avatar
Sebastien Robin committed
671

672 673 674 675 676 677 678 679 680
  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')
    self.stepCheckPackingListIsPacked(sequence=sequence,
                                      packing_list=packing_list)

681 682 683
  def stepCreateCurrency(self, sequence, **kw) :
    """Create a default currency. """
    currency_module = self.getCurrencyModule()
684
    if currency_module._getOb('EUR', None) is None:
685 686 687 688 689 690
      currency = self.getCurrencyModule().newContent(
          portal_type='Currency',
          id="EUR",
          base_unit_quantity=0.01,
          )
    else:
691
      currency = currency_module._getOb('EUR')
692 693 694 695 696 697 698 699 700 701 702 703 704
    sequence.edit(currency=currency)
 
  def stepSetOrderPriceCurrency(self, sequence, **kw) :
    """Set the price currency of the order.

    This step is not necessary.
    TODO : - include a test without this step.
           - include a test with this step late.
    """
    currency = sequence.get('currency')
    order = sequence.get('order')
    order.setPriceCurrency(currency.getRelativeUrl())

705

706
 
707
class TestPackingList(TestPackingListMixin, ERP5TypeTestCase) :
708

709
  run_all_test = 1
710 711 712
  quiet = 0

  def test_01_PackingListDecreaseQuantity(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
713 714 715
    """
      Change the quantity on an delivery line, then
      see if the packing list is divergent and then
716
      split and defer the packing list
Sebastien Robin's avatar
Sebastien Robin committed
717 718 719 720 721 722
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
723 724 725 726 727 728
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
Sebastien Robin's avatar
Sebastien Robin committed
729 730 731
                      '
    sequence_list.addSequenceString(sequence_string)

732
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
733

734
  def test_02_PackingListChangeDestination(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
735 736 737 738 739
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
740
                      stepChangePackingListDestination \
741 742
                      stepCheckPackingListIsCalculating \
                      stepAcceptDecisionPackingList \
743
                      stepTic \
744 745
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListIsNotDivergent \
746
                      stepCheckSimulationDestinationUpdated \
Sebastien Robin's avatar
Sebastien Robin committed
747 748 749
                      '
    sequence_list.addSequenceString(sequence_string)

750
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
751

752
  def test_03_PackingListChangeStartDate(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
753 754 755 756 757
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
758 759
                      stepChangePackingListStartDate \
                      stepCheckPackingListIsCalculating \
760
                      stepAcceptDecisionPackingList \
761 762 763 764
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckSimulationStartDateUpdated \
Sebastien Robin's avatar
Sebastien Robin committed
765 766 767
                      '
    sequence_list.addSequenceString(sequence_string)

768
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
769

770
  def test_04_PackingListDeleteLine(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
771 772 773 774 775
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
776 777 778 779 780
                      stepCheckSimulationConnected \
                      stepDeletePackingListLine \
                      stepCheckPackingListIsNotDivergent \
                      stepTic \
                      stepCheckSimulationDisconnected \
Sebastien Robin's avatar
Sebastien Robin committed
781 782 783
                      '
    sequence_list.addSequenceString(sequence_string)

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

786
  def test_05_SimulationChangeQuantity(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
787 788 789 790 791
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
792 793 794 795 796 797 798 799
                      stepModifySimulationLineQuantity \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListLineWithNewQuantityPrevision \
Sebastien Robin's avatar
Sebastien Robin committed
800 801 802
                      '
    sequence_list.addSequenceString(sequence_string)

803
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
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 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
  def test_05a_SimulationChangeQuantityAndAcceptDecision(self, quiet=quiet, run=run_all_test):
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
                      stepModifySimulationLineQuantity \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAcceptDecisionPackingList \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckSimulationQuantityUpdated \
                      '
    sequence_list.addSequenceString(sequence_string)

    sequence_list.play(self, quiet=quiet)

  def test_05b_SimulationChangeQuantityForMergedLine(self, quiet=quiet, run=run_all_test):
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence_with_duplicated_lines + '\
                      stepModifySimulationLineQuantityForMergedLine \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListLineWithNewQuantityPrevisionForMergedLine \
                      '
    sequence_list.addSequenceString(sequence_string)

    sequence_list.play(self, quiet=quiet)

  def test_05c_SimulationChangeQuantityAndAcceptDecisionForMergedLine(self, quiet=quiet, run=run_all_test):
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence_with_duplicated_lines + '\
                      stepModifySimulationLineQuantityForMergedLine \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAcceptDecisionPackingList \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckSimulationQuantityUpdatedForMergedLine \
                      '
    sequence_list.addSequenceString(sequence_string)

    sequence_list.play(self, quiet=quiet)

862
  def test_06_SimulationChangeStartDate(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
863 864 865 866 867
    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
                      stepModifySimulationLineStartDate \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckNewPackingListAfterStartDateAdopt \
Sebastien Robin's avatar
Sebastien Robin committed
875
                      '
876
    # XXX Check if there is a new packing list created
Sebastien Robin's avatar
Sebastien Robin committed
877 878
    sequence_list.addSequenceString(sequence_string)

879
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
880

881
  def test_07_SimulationChangeStartDateWithTwoOrderLine(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
882 883 884 885
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
886
    sequence_string = self.default_sequence_with_two_lines + '\
887 888 889 890 891 892 893 894 895
                      stepModifySimulationLineStartDate \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepCheckPackingListIsDivergent \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckNewPackingListAfterStartDateAdopt \
Sebastien Robin's avatar
Sebastien Robin committed
896 897 898 899
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)

900
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
901

902
  def test_08_AddContainers(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
903 904 905 906 907
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
908 909 910 911 912 913 914
                      stepAddPackingListContainer \
                      stepAddPackingListContainerLine \
                      stepSetContainerLineSmallQuantity \
                      stepCheckPackingListIsNotPacked \
                      stepSetContainerFullQuantity \
                      stepTic \
                      stepCheckPackingListIsPacked \
Sebastien Robin's avatar
Sebastien Robin committed
915 916 917 918
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)

919
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
920

921
  def test_09_AddContainersWithVariatedResources(self, quiet=quiet, run=run_all_test):
922 923 924
    if not run: return
    sequence_list = SequenceList()

925 926
    # Test with a order with cells
    sequence_string = self.variated_default_sequence + '\
927 928 929 930 931 932 933
                      stepAddPackingListContainer \
                      stepAddPackingListContainerLine \
                      stepSetContainerLineSmallQuantity \
                      stepCheckPackingListIsNotPacked \
                      stepSetContainerFullQuantity \
                      stepTic \
                      stepCheckPackingListIsPacked \
934 935 936
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)
937
    
938
    sequence_list.play(self, quiet=quiet)
939

940
  def test_10_PackingListIncreaseQuantity(self, quiet=quiet, run=run_all_test):
941
    """
942 943 944 945 946 947 948 949
    - 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.
950 951 952 953 954 955
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
956 957 958 959
                      stepIncreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
960 961 962
                      stepCheckPackingListIsDiverged \
                      stepCheckPackingListIsDivergent \
                      stepCheckPackingListNotSolved \
963 964 965
                      '
    sequence_list.addSequenceString(sequence_string)

966
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
967

968 969
  def test_11_PackingListDecreaseTwoTimesQuantityAndUpdateDelivery(self,
                                               quiet=quiet, run=run_all_test):
970 971 972 973 974 975 976 977 978 979
    """
      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 + '\
980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckNewPackingListIsDivergent \
                      stepNewPackingListAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplittedTwoTimes \
995 996 997
                      '
    sequence_list.addSequenceString(sequence_string)

998
    sequence_list.play(self, quiet=quiet)
999

1000
  def test_12_PackingListLineChangeResource(self, quiet=quiet, run=run_all_test):
1001 1002 1003 1004 1005 1006 1007 1008
    """
    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 + '\
1009 1010 1011 1012 1013
                      stepCreateNotVariatedResource \
                      stepChangePackingListLineResource \
                      stepCheckPackingListIsCalculating \
                      stepTic \
                      stepCheckPackingListIsDivergent \
1014 1015 1016
                      '
    sequence_list.addSequenceString(sequence_string)

1017
    sequence_list.play(self, quiet=quiet)
1018

1019
  def test_14_PackingListHavePriceCurrencyCategory(self, quiet=quiet,
1020
                                                   run=run_all_test):
1021 1022 1023 1024
    """Deliveries must have a price currency category. #252
    """
    if not run:
      return
1025 1026 1027 1028
    pl = self.getPortal().getDefaultModule(self.packing_list_portal_type
               ).newContent(portal_type=self.packing_list_portal_type)
    self.failUnless(hasattr(pl, 'getPriceCurrency'))
    
Jérome Perrin's avatar
Jérome Perrin committed
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
  def test_PackingList_viewAsODT(self):
    # tests packing list printout
    resource = self.portal.getDefaultModule(
        self.resource_portal_type).newContent(
                    portal_type=self.resource_portal_type,
                    title='Resource',)
    client = self.portal.organisation_module.newContent(
                              portal_type='Organisation', title='Client')
    vendor = self.portal.organisation_module.newContent(
                              portal_type='Organisation', title='Vendor')
    packing_list = self.portal.getDefaultModule(self.packing_list_portal_type).newContent(
                              portal_type=self.packing_list_portal_type,
                              title='Packing List',
                              source_value=vendor,
                              source_section_value=vendor,
                              destination_value=client,
                              destination_section_value=client)
1046 1047
    line = packing_list.newContent(
                            portal_type=self.packing_list_line_portal_type,
Jérome Perrin's avatar
Jérome Perrin committed
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
                            resource_value=resource,
                            quantity=10,
                            price=3)
    packing_list.confirm()
    get_transaction().commit()
    self.tic()
    
    odt = packing_list.PackingList_viewAsODT()
    from Products.ERP5OOo.tests.utils import Validator
    odf_validator = Validator()
    err_list = odf_validator.validate(odt)
    if err_list:
      self.fail(''.join(err_list))
  
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095

class TestPurchasePackingListMixin(TestPackingListMixin):
  """Mixing class with steps to test purchase packing lists.
  """
  order_portal_type = 'Purchase Order'
  order_line_portal_type = 'Purchase Order Line'
  order_cell_portal_type = 'Purchase Order Cell'
  packing_list_portal_type = 'Purchase Packing List'
  packing_list_line_portal_type = 'Purchase Packing List Line'
  packing_list_cell_portal_type = 'Purchase Packing List Cell'
  delivery_builder_id = 'purchase_packing_list_builder'
  container_portal_type = None
  container_line_portal_type = None
  container_cell_portal_type = None
  
  # all steps related to packing and container does not apply on purchase
  def ignored_step(self, **kw):
    return
  stepAddPackingListContainer = ignored_step
  stepDefineNewPackingListContainer = ignored_step
  stepAddPackingListContainerLine = ignored_step
  stepSetContainerLineSmallQuantity = ignored_step
  stepSetContainerLineFullQuantity = ignored_step
  stepSetContainerFullQuantity = ignored_step
  stepCheckPackingListIsNotPacked = ignored_step
  stepCheckPackingListIsPacked = ignored_step
  stepCheckNewPackingListIsPacked = ignored_step


class TestPurchasePackingList(TestPurchasePackingListMixin, TestPackingList):
  """Tests for purchase packing list.
  """


1096 1097 1098
def test_suite():
  suite = unittest.TestSuite()
  suite.addTest(unittest.makeSuite(TestPackingList))
1099
  suite.addTest(unittest.makeSuite(TestPurchasePackingList))
1100
  return suite
Sebastien Robin's avatar
Sebastien Robin committed
1101