testPackingList.py 39.2 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 44 45 46 47
  container_portal_type = 'Container'
  container_line_portal_type = 'Container Line'
  container_cell_portal_type = 'Container Cell'

  default_sequence = 'stepCreateOrganisation1 \
                      stepCreateOrganisation2 \
                      stepCreateOrganisation3 \
                      stepCreateOrder \
48 49
                      stepCreateCurrency \
                      stepSetOrderPriceCurrency \
50 51 52 53 54 55 56 57 58 59 60 61
                      stepSetOrderProfile \
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
62 63
                      stepCheckPackingListIsNotDivergent \
                      stepCheckOrderPackingList '
64

65 66
  default_sequence_with_two_lines = '\
                      stepCreateOrganisation1 \
67 68 69
                      stepCreateOrganisation2 \
                      stepCreateOrganisation3 \
                      stepCreateOrder \
70 71
                      stepCreateCurrency \
                      stepSetOrderPriceCurrency \
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
                      stepSetOrderProfile \
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepCreateNotVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
89 90
                      stepCheckPackingListIsNotDivergent \
                      stepCheckOrderPackingList'
91

92 93
  variated_default_sequence = '\
                      stepCreateOrganisation1 \
94 95 96
                      stepCreateOrganisation2 \
                      stepCreateOrganisation3 \
                      stepCreateOrder \
97 98
                      stepCreateCurrency \
                      stepSetOrderPriceCurrency \
99 100 101 102 103 104 105 106 107 108 109 110 111 112
                      stepSetOrderProfile \
                      stepCreateVariatedResource \
                      stepTic \
                      stepCreateOrderLine \
                      stepSetOrderLineResource \
                      stepSetOrderLineDefaultValues \
                      stepSetOrderLineFullVCL \
                      stepCompleteOrderLineMatrix \
                      stepOrderOrder \
                      stepTic \
                      stepConfirmOrder \
                      stepTic \
                      stepCheckOrderSimulation \
                      stepCheckDeliveryBuilding \
113 114
                      stepCheckPackingListIsNotDivergent \
                      stepCheckOrderPackingList'
115

Sebastien Robin's avatar
Sebastien Robin committed
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
  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

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
  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(), \
		                       order.getDestinationSection())
    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())
152 153
    self.assertEquals(packing_list.getPriceCurrency(), \
                                       order.getPriceCurrency())
154

155 156
  def stepCheckPackingListIsDivergent(self, sequence=None, sequence_list=None, 
                                      packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
157 158 159
    """
      Test if packing list is divergent
    """
160 161
    if packing_list is None:
      packing_list = sequence.get('packing_list')
162 163
    self.failIf('Site Error' in packing_list.view())
    self.assertTrue(packing_list.isDivergent())
164 165 166 167 168 169

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

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

  def stepCheckPackingListIsSolved(self, sequence=None, sequence_list=None, **kw):
    """
182
      Test if packing list is solved
183 184 185 186 187 188 189 190 191
    """
    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')
192
    self.assertEquals('diverged', packing_list.getCausalityState())
193

Sebastien Robin's avatar
Sebastien Robin committed
194 195 196 197 198
  def stepCheckPackingListIsNotDivergent(self, sequence=None, sequence_list=None, **kw):
    """
      Test if packing list is not divergent
    """
    packing_list = sequence.get('packing_list')
199
    self.assertFalse(packing_list.isDivergent())
Sebastien Robin's avatar
Sebastien Robin committed
200

201 202 203 204 205 206 207 208 209 210 211
  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)

212 213
  def stepDecreasePackingListLineQuantity(self, sequence=None,
      sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
214
    """
215
    Set a decreased quantity on packing list lines
Sebastien Robin's avatar
Sebastien Robin committed
216 217
    """
    packing_list = sequence.get('packing_list')
218
    quantity = sequence.get('line_quantity',default=self.default_quantity)
219
    quantity = quantity - 1
220
    sequence.edit(line_quantity=quantity)
Sebastien Robin's avatar
Sebastien Robin committed
221
    for packing_list_line in packing_list.objectValues(
222
        portal_type=self.packing_list_line_portal_type):
223
      packing_list_line.edit(quantity=quantity)
224
    sequence.edit(last_delta = sequence.get('last_delta', 0.0) - 1.0)
Sebastien Robin's avatar
Sebastien Robin committed
225

226 227
  def stepIncreasePackingListLineQuantity(self, sequence=None,
      sequence_list=None, **kw):
228
    """
229
    Set a increased quantity on packing list lines
230 231
    """
    packing_list = sequence.get('packing_list')
232 233 234
    quantity = sequence.get('line_quantity',default=self.default_quantity)
    quantity = quantity + 1
    sequence.edit(line_quantity=quantity)
235
    for packing_list_line in packing_list.objectValues(
236
        portal_type=self.packing_list_line_portal_type):
237 238
      packing_list_line.edit(quantity=quantity)
    sequence.edit(last_delta = sequence.get('last_delta', 0.0) + 1.0)
239

Sebastien Robin's avatar
Sebastien Robin committed
240 241 242 243 244 245 246 247 248 249 250
  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):
    """
251
      Test if packing list was splitted
Sebastien Robin's avatar
Sebastien Robin committed
252 253 254 255 256 257 258 259 260 261 262 263
    """
    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
264
    sequence.edit(new_packing_list=packing_list2)
Sebastien Robin's avatar
Sebastien Robin committed
265 266 267 268 269 270 271
    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())

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
  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())

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

339 340
  def stepChangePackingListDestination(self, sequence=None, 
                                       sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
341 342 343 344 345
    """
      Test if packing list is divergent
    """
    organisation3 = sequence.get('organisation3')
    packing_list = sequence.get('packing_list')
346
    packing_list.edit(destination_value=organisation3)
Sebastien Robin's avatar
Sebastien Robin committed
347 348 349 350 351 352 353 354 355 356 357 358

  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
359
      Test if the destination of the simulation movement was changed
Sebastien Robin's avatar
Sebastien Robin committed
360 361 362 363 364 365 366 367 368 369
    """
    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
370
      Change the start_date of the packing_list.
Sebastien Robin's avatar
Sebastien Robin committed
371 372
    """
    packing_list = sequence.get('packing_list')
373
    packing_list.edit(start_date=self.datetime + 15)
Sebastien Robin's avatar
Sebastien Robin committed
374 375 376

  def stepCheckSimulationStartDateUpdated(self,sequence=None, sequence_list=None, **kw):
    """
Alexandre Boeglin's avatar
Alexandre Boeglin committed
377
      Test if the start_date of the simulation movement was changed
Sebastien Robin's avatar
Sebastien Robin committed
378 379 380 381 382 383 384
    """
    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)

385 386 387 388 389 390 391
  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
392 393
  def stepDeletePackingListLine(self,sequence=None, sequence_list=None, **kw):
    """
394
      Deletes a Packing List Line
Sebastien Robin's avatar
Sebastien Robin committed
395 396 397 398 399
    """
    packing_list = sequence.get('packing_list')
    packing_list_line_id = sequence.get('packing_list_line').getId()
    packing_list.manage_delObjects([packing_list_line_id])

400 401 402 403 404 405 406 407 408 409 410 411 412
  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
413 414
  def stepCheckSimulationConnected(self,sequence=None, sequence_list=None, **kw):
    """
415
      Check if simulation movement are connected
Sebastien Robin's avatar
Sebastien Robin committed
416 417 418 419 420 421 422 423
    """
    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)
424 425
      self.assertEquals(packing_list_line.getCausalityValue(), 
                        simulation_line.getOrderValue())
Sebastien Robin's avatar
Sebastien Robin committed
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444

  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:
445
      simulation_line.edit(quantity=self.default_quantity-1)
Sebastien Robin's avatar
Sebastien Robin committed
446 447 448 449 450 451 452

  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()
453 454
    resource_list = sequence.get('resource_list')
    self.assertEquals(len(simulation_line_list),len(resource_list))
Sebastien Robin's avatar
Sebastien Robin committed
455
    for simulation_line in simulation_line_list:
456
      simulation_line.edit(start_date=self.datetime+15)
Sebastien Robin's avatar
Sebastien Robin committed
457

458 459
  def stepAdoptPrevision(self,sequence=None, sequence_list=None, 
                         packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
460 461 462
    """
      Check if simulation movement are disconnected
    """
463 464
    if packing_list is None:
      packing_list = sequence.get('packing_list')
465 466
    LOG('packing_list.getSimulationState()',0,packing_list.getSimulationState())
    LOG('packing_list.getCausalityState()',0,packing_list.getCausalityState())
Sebastien Robin's avatar
Sebastien Robin committed
467 468
    packing_list.portal_workflow.doActionFor(packing_list,'adopt_prevision_action')

469 470 471 472 473 474 475
  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)

476
  def stepAcceptDecisionPackingList(self,sequence=None, sequence_list=None, **kw):
477 478 479 480 481 482
    """
      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
483 484 485 486 487 488 489 490 491 492 493 494 495
  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')
496 497 498
    packing_list = sequence.get('packing_list')
    LOG('CheckNewPackingList, self.datetime+15',0,self.datetime+15)
    LOG('CheckNewPackingList, packing_list.getStartDate',0,packing_list.getStartDate())
499 500
    self.assertEquals(packing_list_line.getQuantity(),self.default_quantity)
    self.assertEquals(packing_list.getStartDate(),self.datetime+15)
Sebastien Robin's avatar
Sebastien Robin committed
501
    simulation_line_list = applied_rule.objectValues()
502 503 504
    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
505
    for simulation_line in simulation_line_list:
506
#      self.assertNotEquals(simulation_line.getDeliveryValue(),None)
507
      delivery_value = simulation_line.getDeliveryValue()
508 509 510 511 512
      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
513

514 515
  def stepAddPackingListContainer(self,sequence=None, 
                                  packing_list=None,sequence_list=None, **kw):
Sebastien Robin's avatar
Sebastien Robin committed
516 517 518
    """
      Check if simulation movement are disconnected
    """
519 520
    if packing_list is None:
      packing_list = sequence.get('packing_list')
521
    container = packing_list.newContent(portal_type=self.container_portal_type)
Sebastien Robin's avatar
Sebastien Robin committed
522 523
    sequence.edit(container=container)

524 525 526 527 528 529 530 531 532
  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
533 534 535 536 537
  def stepAddPackingListContainerLine(self,sequence=None, sequence_list=None, **kw):
    """
      Check if simulation movement are disconnected
    """
    container = sequence.get('container')
538
    container_line = container.newContent(portal_type=self.container_line_portal_type)
Sebastien Robin's avatar
Sebastien Robin committed
539 540
    sequence.edit(container_line=container_line)
    resource = sequence.get('resource')
541
    container_line.edit(resource_value=resource)
Sebastien Robin's avatar
Sebastien Robin committed
542 543 544 545 546 547 548 549

  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)

550 551
  def stepSetContainerLineFullQuantity(self,sequence=None, sequence_list=None, 
                                       quantity=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
552 553 554 555
    """
      Check if simulation movement are disconnected
    """
    container_line = sequence.get('container_line')
556 557 558
    if quantity is None:
      quantity = sequence.get('line_quantity',self.default_quantity)
    container_line.edit(quantity=quantity)
559
    container_line.immediateReindexObject()
Sebastien Robin's avatar
Sebastien Robin committed
560

561 562 563 564 565 566 567 568 569 570 571 572 573 574
  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 = \
575
          container.newContent(portal_type=self.container_line_portal_type)
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
      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,
594
                portal_type=self.container_cell_portal_type, *cell_key)
595 596 597 598 599 600 601
            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
602 603 604 605 606 607 608
  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())
609
    self.assertEquals('missing',packing_list.getContainerState())
Sebastien Robin's avatar
Sebastien Robin committed
610

611 612
  def stepCheckPackingListIsPacked(self,sequence=None, sequence_list=None, 
                                   packing_list=None,**kw):
Sebastien Robin's avatar
Sebastien Robin committed
613 614 615 616
    """
      Check that the number of objects in containers are
      equals to the quantity of the packing list
    """
617 618
    if packing_list is None:
      packing_list = sequence.get('packing_list')
619
    get_transaction().commit()
Sebastien Robin's avatar
Sebastien Robin committed
620
    self.assertEquals(1,packing_list.isPacked())
621
    self.assertEquals('packed',packing_list.getContainerState())
Sebastien Robin's avatar
Sebastien Robin committed
622

623 624 625 626 627 628 629 630 631
  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)

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
  def stepCreateCurrency(self, sequence, **kw) :
    """Create a default currency. """
    currency_module = self.getCurrencyModule()
    if len(currency_module.objectValues(id='EUR'))==0:
      currency = self.getCurrencyModule().newContent(
          portal_type='Currency',
          id="EUR",
          base_unit_quantity=0.01,
          )
    else:
      currency = currency_module.objectValues(id='EUR')[0]
    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())

656

657
 
658
class TestPackingList(TestPackingListMixin, ERP5TypeTestCase) :
659

660
  run_all_test = 1
661 662 663
  quiet = 0

  def test_01_PackingListDecreaseQuantity(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
664 665 666
    """
      Change the quantity on an delivery line, then
      see if the packing list is divergent and then
667
      split and defer the packing list
Sebastien Robin's avatar
Sebastien Robin committed
668 669 670 671 672 673
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
674 675 676 677 678 679
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
Sebastien Robin's avatar
Sebastien Robin committed
680 681 682
                      '
    sequence_list.addSequenceString(sequence_string)

683
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
684

685
  def test_02_PackingListChangeDestination(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
686 687 688 689 690 691 692 693
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
694
                      stepChangePackingListDestination \
695 696
                      stepCheckPackingListIsCalculating \
                      stepAcceptDecisionPackingList \
697
                      stepTic \
698 699
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListIsNotDivergent \
700
                      stepCheckSimulationDestinationUpdated \
Sebastien Robin's avatar
Sebastien Robin committed
701 702 703
                      '
    sequence_list.addSequenceString(sequence_string)

704
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
705

706
  def test_03_PackingListChangeStartDate(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
707 708 709 710 711 712 713 714
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
715 716
                      stepChangePackingListStartDate \
                      stepCheckPackingListIsCalculating \
717
                      stepAcceptDecisionPackingList \
718 719 720 721
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckSimulationStartDateUpdated \
Sebastien Robin's avatar
Sebastien Robin committed
722 723 724
                      '
    sequence_list.addSequenceString(sequence_string)

725
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
726

727
  def test_04_PackingListDeleteLine(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
728 729 730 731 732 733 734 735
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
736 737 738 739 740
                      stepCheckSimulationConnected \
                      stepDeletePackingListLine \
                      stepCheckPackingListIsNotDivergent \
                      stepTic \
                      stepCheckSimulationDisconnected \
Sebastien Robin's avatar
Sebastien Robin committed
741 742 743
                      '
    sequence_list.addSequenceString(sequence_string)

744
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
745

746
  def test_05_SimulationChangeQuantity(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
747 748 749 750 751 752 753 754
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
755 756 757 758 759 760 761 762
                      stepModifySimulationLineQuantity \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListLineWithNewQuantityPrevision \
Sebastien Robin's avatar
Sebastien Robin committed
763 764 765
                      '
    sequence_list.addSequenceString(sequence_string)

766
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
767

768
  def test_06_SimulationChangeStartDate(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
769 770 771 772 773 774 775 776
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
777 778 779 780 781 782 783
                      stepModifySimulationLineStartDate \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckNewPackingListAfterStartDateAdopt \
Sebastien Robin's avatar
Sebastien Robin committed
784
                      '
785
    # XXX Check if there is a new packing list created
Sebastien Robin's avatar
Sebastien Robin committed
786 787
    sequence_list.addSequenceString(sequence_string)

788
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
789

790
  def test_07_SimulationChangeStartDateWithTwoOrderLine(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
791 792 793 794 795 796 797
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
798
    sequence_string = self.default_sequence_with_two_lines + '\
799 800 801 802 803 804 805 806 807
                      stepModifySimulationLineStartDate \
                      stepTic \
                      stepCheckPackingListIsDiverged \
                      stepCheckPackingListIsDivergent \
                      stepAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsNotDivergent \
                      stepCheckPackingListIsSolved \
                      stepCheckNewPackingListAfterStartDateAdopt \
Sebastien Robin's avatar
Sebastien Robin committed
808 809 810 811
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)

812
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
813

814
  def test_08_AddContainers(self, quiet=quiet, run=run_all_test):
Sebastien Robin's avatar
Sebastien Robin committed
815 816 817 818 819 820 821 822
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
823 824 825 826 827 828 829
                      stepAddPackingListContainer \
                      stepAddPackingListContainerLine \
                      stepSetContainerLineSmallQuantity \
                      stepCheckPackingListIsNotPacked \
                      stepSetContainerFullQuantity \
                      stepTic \
                      stepCheckPackingListIsPacked \
Sebastien Robin's avatar
Sebastien Robin committed
830 831 832 833
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)

834
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
835

836
  def test_09_AddContainersWithVariatedResources(self, quiet=quiet, run=run_all_test):
837 838 839 840 841 842
    """
      Test generation of delivery list
    """
    if not run: return
    sequence_list = SequenceList()

843 844
    # Test with a order with cells
    sequence_string = self.variated_default_sequence + '\
845 846 847 848 849 850 851
                      stepAddPackingListContainer \
                      stepAddPackingListContainerLine \
                      stepSetContainerLineSmallQuantity \
                      stepCheckPackingListIsNotPacked \
                      stepSetContainerFullQuantity \
                      stepTic \
                      stepCheckPackingListIsPacked \
852 853 854
                      '
    # XXX Check if there is a new packing list created
    sequence_list.addSequenceString(sequence_string)
855
    
856
    sequence_list.play(self, quiet=quiet)
857

858
  def test_10_PackingListIncreaseQuantity(self, quiet=quiet, run=run_all_test):
859
    """
860 861 862 863 864 865 866 867
    - 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.
868 869 870 871 872 873
    """
    if not run: return
    sequence_list = SequenceList()

    # Test with a simply order without cell
    sequence_string = self.default_sequence + '\
874 875 876 877
                      stepIncreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
878 879 880
                      stepCheckPackingListIsDiverged \
                      stepCheckPackingListIsDivergent \
                      stepCheckPackingListNotSolved \
881 882 883
                      '
    sequence_list.addSequenceString(sequence_string)

884
    sequence_list.play(self, quiet=quiet)
Sebastien Robin's avatar
Sebastien Robin committed
885

886 887
  def test_11_PackingListDecreaseTwoTimesQuantityAndUpdateDelivery(self,
                                               quiet=quiet, run=run_all_test):
888 889 890 891 892 893 894 895 896 897
    """
      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 + '\
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplitted \
                      stepDecreasePackingListLineQuantity \
                      stepCheckPackingListIsCalculating \
                      stepSplitAndDeferPackingList \
                      stepTic \
                      stepCheckNewPackingListIsDivergent \
                      stepNewPackingListAdoptPrevision \
                      stepTic \
                      stepCheckPackingListIsSolved \
                      stepCheckPackingListSplittedTwoTimes \
913 914 915
                      '
    sequence_list.addSequenceString(sequence_string)

916
    sequence_list.play(self, quiet=quiet)
917

918
  def test_12_PackingListLineChangeResource(self, quiet=quiet, run=run_all_test):
919 920 921 922 923 924 925 926
    """
    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 + '\
927 928 929 930 931
                      stepCreateNotVariatedResource \
                      stepChangePackingListLineResource \
                      stepCheckPackingListIsCalculating \
                      stepTic \
                      stepCheckPackingListIsDivergent \
932 933 934
                      '
    sequence_list.addSequenceString(sequence_string)

935
    sequence_list.play(self, quiet=quiet)
936

937
  def test_14_PackingListHavePriceCurrencyCategory(self, quiet=quiet,
938
                                                   run=run_all_test):
939 940 941 942
    """Deliveries must have a price currency category. #252
    """
    if not run:
      return
943 944 945 946
    pl = self.getPortal().getDefaultModule(self.packing_list_portal_type
               ).newContent(portal_type=self.packing_list_portal_type)
    self.failUnless(hasattr(pl, 'getPriceCurrency'))
    
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981

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'
  order_workflow_id = 'order_workflow'
  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.
  """


982 983 984
def test_suite():
  suite = unittest.TestSuite()
  suite.addTest(unittest.makeSuite(TestPackingList))
985
  suite.addTest(unittest.makeSuite(TestPurchasePackingList))
986
  return suite
Sebastien Robin's avatar
Sebastien Robin committed
987