Skip to content

erp5
erp5
Commit ae83d638 authored by Julien Muchembled's avatar Julien Muchembled
Browse files
Options

Make testLegacyReturnedSalePackingList a virtual copy of testReturnedSalePackingList 

As long as there is very few differences between testReturnedSalePackingList
and testLegacyReturnedSalePackingList, it is more maintainable not to copy and
paste everything.

If a future change in testReturnedSalePackingList breaks
testLegacyReturnedSalePackingList, then we'll reconsider duplicating the whole
file.

git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@41552 20353a03-c40f-0410-a6d1-a30d3c3de9de
parent f1dfe71b
Show whitespace changes
Inline Side-by-side
Showing with 3 additions and 563 deletions
product/ERP5/tests/testReturnedSalePackingList.py
View file @ ae83d638
......@@ -33,7 +33,7 @@ from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
from zLOG import LOG
from AccessControl.SecurityManagement import newSecurityManager
from Products.ERP5Type.tests.Sequence import SequenceList
from testPackingList import TestPackingListMixin
from Products.ERP5.tests.testPackingList import TestPackingListMixin
from DateTime import DateTime
from Products.ERP5Type.Errors import UnsupportedWorkflowMethod
from Products.ERP5.tests.utils import newSimulationExpectedFailure
......
product/ERP5Legacy/tests/testLegacyReturnedSalePackingList.py
View file @ ae83d638
......@@ -26,565 +26,5 @@
#
##############################################################################
import unittest
import transaction
from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
from zLOG import LOG
from AccessControl.SecurityManagement import newSecurityManager
from Products.ERP5Type.tests.Sequence import SequenceList
from testLegacyPackingList import TestPackingListMixin
from DateTime import DateTime
from Products.ERP5Type.Errors import UnsupportedWorkflowMethod
class ReturnedSalePackingListMixin(TestPackingListMixin):
"""Mixing class with steps to test returned sale packing lists.
"""
returned_packing_list_portal_type = 'Returned Sale Packing List'
returned_packing_list_line_portal_type = 'Returned Sale Packing List Line'
returned_packing_list_cell_portal_type = 'Returned Sale Packing List Cell'
inventory_line_portal_type = 'Inventory Line'
view_stock_date = '2009/12/01'
first_date_string = '2009/01/01'
shipping_date_string = '2009/10/03'
inventory_quantity = 2000.
default_sequence = '\
stepCreateOrganisation1 \
stepCreateOrganisation2 \
stepCreateOrganisation3 \
stepCreateCurrency \
stepCreateNotVariatedResource \
stepTic '
def beforeTearDown(self):
transaction.abort()
self.tic()
for folder in (self.portal.organisation_module,
self.portal.sale_order_module,
self.portal.inventory_module,
self.portal.apparel_model_module,
self.portal.product_module,
self.portal.returned_sale_packing_list_module,
self.portal.portal_simulation,):
folder.manage_delObjects([x for x in folder.objectIds()])
transaction.commit()
self.tic()
def loginAsManager(self, quiet=0, run=1):
uf = self.getPortal().acl_users
uf._doAddUser('manager', '', ['Manager', 'Member', 'Assignee'], [])
user = uf.getUserById('manager').__of__(uf)
newSecurityManager(None, user)
def loginAsMember(self, quiet=0, run=1):
uf = self.getPortal().acl_users
uf._doAddUser('member', '', ['Member', 'Assignor'], [])
user = uf.getUserById('member').__of__(uf)
newSecurityManager(None, user)
def afterSetUp(self, quiet=1, run=1):
self.loginAsManager()
portal = self.getPortal()
self.createCategories()
self.validateRules()
self.setUpPreferences()
# test with not a manager
self.loginAsMember()
def stepCreateReturnedPackingList(self, sequence=None, sequence_list=None, **kw):
"""
Adds a Returned Packing List
"""
returned_packing_list = self.getPortal().getDefaultModule(
self.returned_packing_list_portal_type).newContent(
portal_type=self.returned_packing_list_portal_type)
organisation = sequence.get('organisation1')
organisation3 = sequence.get('organisation3')
start_date = DateTime(self.shipping_date_string)
returned_packing_list.edit(
title = "RPL%s" % returned_packing_list.getId(),
start_date = start_date,
stop_date = start_date + 20,
)
if organisation is not None:
returned_packing_list.edit(source_value=organisation3,
source_section_value=organisation3,
destination_value=organisation,
destination_section_value=organisation,
source_decision_value=organisation3,
destination_decision_value=organisation,
source_administration_value=organisation3,
destination_administration_value=organisation,
)
returned_packing_list_line = returned_packing_list.newContent(
portal_type=self.returned_packing_list_line_portal_type)
resource = sequence.get('resource')
returned_packing_list_line.setResourceValue(resource)
returned_packing_list_line.edit(quantity=200)
sequence.edit(returned_packing_list=returned_packing_list)
def stepCheckReturnedPackingListCreating(self, sequence=None, sequence_list=None, **kw):
"""
Check that returned packing list creating
"""
returned_packing_list = sequence.get('returned_packing_list')
organisation = sequence.get('organisation1')
organisation3 = sequence.get('organisation3')
self.assertEquals(organisation3, returned_packing_list.getSourceValue())
self.assertEquals(organisation3, returned_packing_list.getSourceSectionValue())
self.assertEquals(organisation, returned_packing_list.getDestinationValue())
self.assertEquals(organisation, returned_packing_list.getDestinationSectionValue())
self.assertEquals(organisation3, returned_packing_list.getSourceDecisionValue())
self.assertEquals(organisation, returned_packing_list.getDestinationDecisionValue())
self.assertEquals(organisation3, returned_packing_list.getSourceAdministrationValue())
self.assertEquals(organisation, returned_packing_list.getDestinationAdministrationValue())
returned_packing_list_line_list = returned_packing_list.objectValues(
portal_type=self.returned_packing_list_line_portal_type)
self.assertEquals(1, len(returned_packing_list_line_list))
returned_packing_list_line = returned_packing_list_line_list[0]
self.assertEquals(self.returned_packing_list_line_portal_type,
returned_packing_list_line.getPortalType())
resource = sequence.get('resource')
created_resource = returned_packing_list_line.getResourceValue()
self.assertEquals(resource, created_resource)
self.assertEquals(200, returned_packing_list_line.getQuantity())
def stepCheckReturnedPackingListDeleting(self, sequence=None,
sequence_list=None, **kw):
"""
Check that returned packing list deleting
"""
returned_packing_list = sequence.get('returned_packing_list')
returned_packing_list_line_list = returned_packing_list.objectValues(
portal_type=self.returned_packing_list_line_portal_type)
self.assertEquals(1, len(returned_packing_list_line_list))
returned_packing_list_line = returned_packing_list_line_list[0]
# delete a line
returned_packing_list.manage_delObjects([returned_packing_list_line.getId()])
portal_catalog = self.getCatalogTool()
returned_packing_list_uid = returned_packing_list.getUid()
found_rpl = portal_catalog(uid=returned_packing_list_uid)
self.assertEquals(1, len(found_rpl))
rpl = found_rpl[0].getObject()
self.assertEquals(0, len(rpl.objectValues(
portal_type=self.returned_packing_list_line_portal_type)))
# delete a delivery
self.portal.returned_sale_packing_list_module.manage_delObjects(
[returned_packing_list.getId(),])
found_rpl = portal_catalog(uid=returned_packing_list_uid)
self.assertEquals(0, len(found_rpl))
def stepConfirmReturnedPackingList(self, sequence=None, sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
returned_packing_list.confirm()
def stepShipReturnedPackingList(self,sequence=None, sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
returned_packing_list.start()
def stepReceiveReturnedPackingList(self,sequence=None, sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
returned_packing_list.stop()
def stepDeliverReturnedPackingList(self,sequence=None, sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
returned_packing_list.deliver()
def stepCheckConfirmedReturnedPackingList(self, sequence=None,
sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
self.assertEquals('confirmed', returned_packing_list.getSimulationState())
def stepCheckShippedReturnedPackingList(self, sequence=None,
sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
self.assertEquals('started', returned_packing_list.getSimulationState())
def stepCheckReceivedReturnedPackingList(self, sequence=None,
sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
self.assertEquals('stopped', returned_packing_list.getSimulationState())
def stepCheckDeliveredReturnedPackingList(self, sequence=None,
sequence_list=None, **kw):
returned_packing_list = sequence.get('returned_packing_list')
self.assertEquals('delivered', returned_packing_list.getSimulationState())
def _getInventoryModule(self):
return getattr(self.getPortal(), 'inventory_module',None)
def stepCreateInitialInventory(self, sequence=None, **kw):
"""
create a inventory
"""
portal = self.getPortal()
organisation = sequence.get('organisation1')
inventory = self._getInventoryModule().newContent()
inventory.edit(start_date=self.first_date_string,
destination_value=organisation,
destination_section_value=organisation)
inventory_list = sequence.get('inventory_list', [])
inventory_line = inventory.newContent(portal_type = self.inventory_line_portal_type)
inventory_line.edit(resource_value = sequence.get('resource'),
quantity = self.inventory_quantity)
inventory.deliver()
inventory_list.append(inventory)
sequence.edit(inventory_list=inventory_list)
def stepCheckInitialInventory(self, sequence=None, sequence_list=None, **kw):
"""
Check that creating inventory and its resource
"""
node_uid = sequence.get('organisation1').getUid()
resource_url = sequence.get('resource').getRelativeUrl()
# inventory quantity:2000 (2009/01/01)
first_date = DateTime(self.first_date_string) + 1
quantity = self.getSimulationTool().getInventory(node_uid=node_uid,
resource=resource_url,
to_date=first_date)
self.assertEquals(2000, quantity)
view_date = DateTime(self.view_stock_date)
quantity = self.getSimulationTool().getInventory(node_uid=node_uid,
resource=resource_url,
to_date=view_date)
self.assertEquals(2000, quantity)
def stepCheckReturnedInventory(self, sequence=None, sequence_list=None, **kw):
"""
Check that returned sale packing list with inventory
"""
# returned packing list returns
# From: 'organisation3'
# To: 'organisation1'
# Quantity: 200
node_uid = sequence.get('organisation1').getUid()
resource_url = sequence.get('resource').getRelativeUrl()
date = DateTime(self.view_stock_date)
quantity = self.getSimulationTool().getInventory(node_uid=node_uid,
resource=resource_url,
to_date=date)
self.assertEquals(2200, quantity)
shipping_date = DateTime(self.shipping_date_string)
quantity = self.getSimulationTool().getInventory(node_uid=node_uid,
resource=resource_url,
to_date=shipping_date)
self.assertEquals(2000, quantity)
def stepCheckReturnedPackingLineEmptyCell(self, sequence=None, \
sequence_list=None, **kw):
"""
Check if the matrix of the current returned packing list is empty.
"""
order_line = sequence.get('returned_packing_list')
cell_list = order_line.objectValues(portal_type=self.order_cell_portal_type)
self.failIfDifferentSet( cell_list , [] )
def stepCreateReturnedPackingListWithCell(self, sequence=None,
sequence_list=None, **kw):
"""
Creating a returned sale packing list with variations
"""
returned_packing_list = self.getPortal().getDefaultModule(
self.returned_packing_list_portal_type).newContent(
portal_type=self.returned_packing_list_portal_type)
organisation = sequence.get('organisation1')
organisation3 = sequence.get('organisation3')
start_date = DateTime(self.shipping_date_string)
returned_packing_list.edit(
title = "RPL%s" % returned_packing_list.getId(),
start_date = start_date,
stop_date = start_date + 20,
)
if organisation is not None:
returned_packing_list.edit(source_value=organisation3,
source_section_value=organisation3,
destination_value=organisation,
destination_section_value=organisation,
source_decision_value=organisation3,
destination_decision_value=organisation,
source_administration_value=organisation3,
destination_administration_value=organisation,
)
returned_packing_list_line = returned_packing_list.newContent(
portal_type=self.returned_packing_list_line_portal_type)
size_list = ['Baby','Child', 'Man', 'Woman']
resource = sequence.get('resource')
resource.edit(
industrial_phase_list=["phase1", "phase2"],
size_list=size_list,
variation_base_category_list=['size']
)
returned_packing_list_line.setResourceValue(resource)
variation_category_list = ['size/Baby', 'size/Child']
resource_vbcl = resource.getVariationBaseCategoryList()
line_vcl = []
for vbc in resource_vbcl:
resource_vcl = list(resource.getVariationCategoryList(
base_category_list=[vbc],
omit_individual_variation=0))
resource_vcl.sort()
line_vcl.extend(self.splitList(resource_vcl)[0])
returned_packing_list_line.setVariationCategoryList(line_vcl)
base_id = 'variation'
returned_packing_list_line.setCellRange(line_vcl, base_id=base_id)
transaction.commit()
self.stepTic()
self.assertEquals(2, len(variation_category_list))
cell_key_list = list(returned_packing_list_line.getCellKeyList(base_id=base_id))
self.assertNotEquals(0, len(cell_key_list))
for cell_key in cell_key_list:
cell = returned_packing_list_line.newCell(base_id=base_id,
portal_type=self.returned_packing_list_cell_portal_type,
*cell_key)
cell.edit(mapped_value_property_list=['price','quantity'],
price=100, quantity=200,
predicate_category_list=cell_key,
variation_category_list=cell_key)
transaction.commit()
cell_list = returned_packing_list_line.objectValues(
portal_type=self.returned_packing_list_cell_portal_type)
self.assertEquals(2, len(cell_list))
sequence.edit(returned_packing_list_with_cell=returned_packing_list)
def stepCheckReturnedPackingListWithCell(self, sequence=None,
sequence_list=None, **kw):
"""
Check that returned sale packing list with variation
"""
rplwc = sequence.get('returned_packing_list_with_cell')
rplwc_line_list = rplwc.objectValues(
portal_type=self.returned_packing_list_line_portal_type)
self.assertEquals(1, len(rplwc_line_list))
rplwc_line = rplwc_line_list[0]
vcl = rplwc_line.getVariationCategoryList(omit_optional_variation=1)
self.assertEquals(2, len(vcl))
cell_list = rplwc_line.objectValues(
portal_type=self.returned_packing_list_cell_portal_type)
self.assertEquals(2, len(cell_list))
def stepCheckReturnedPackingListWithCellDeleting(self, sequence=None,
sequence_list=None, **kw):
"""
Check that deleting cell
"""
rplwc = sequence.get('returned_packing_list_with_cell')
rplwc_line_list = rplwc.objectValues(
portal_type=self.returned_packing_list_line_portal_type)
self.assertEquals(1, len(rplwc_line_list))
rplwc_line = rplwc_line_list[0]
vcl = rplwc_line.getVariationCategoryList(omit_optional_variation=1)
self.assertEquals(2, len(vcl))
cell_list = rplwc_line.objectValues(
portal_type=self.returned_packing_list_cell_portal_type)
self.assertEquals(2, len(cell_list))
# delete cells
rplwc_line.deleteContent(map(lambda x: x.getId(), cell_list))
transaction.commit()
cell_list = rplwc_line.objectValues(
ortal_type=self.returned_packing_list_cell_portal_type)
self.assertEquals(0, len(cell_list))
def stepCheckReturnedPackingListIsNotDivergent(self, sequence=None,
sequence_list=None, **kw):
"""
Test if packing list is not divergent
"""
packing_list = sequence.get('returned_packing_list')
self.assertFalse(packing_list.isDivergent())
class TestReturnedSalePackingList(ReturnedSalePackingListMixin, ERP5TypeTestCase):
"""Tests for returned sale packing list.
"""
run_all_test = 1
quiet = 0
def test_01_ReturnedSalePackingListWithInventory(self, quiet=quiet,
run=run_all_test):
"""
Test that returned sale packing list with its inventory
"""
if not run: return
sequence_list = SequenceList()
sequence_string = self.default_sequence + '\
stepTic \
stepCreateInitialInventory \
stepTic \
stepCheckInitialInventory \
stepCreateReturnedPackingList \
stepConfirmReturnedPackingList \
stepShipReturnedPackingList \
stepReceiveReturnedPackingList \
stepDeliverReturnedPackingList \
stepTic \
stepCheckReturnedInventory \
'
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_02_ReturnedSalePackingListWorkflow(self, quiet=quiet,
run=run_all_test):
"""
Test that returned sale packing list workflow
"""
if not run: return
sequence_list = SequenceList()
sequence_string = self.default_sequence + '\
stepTic \
stepCreateReturnedPackingList \
stepConfirmReturnedPackingList \
stepTic \
stepCheckConfirmedReturnedPackingList \
stepShipReturnedPackingList \
stepTic \
stepCheckShippedReturnedPackingList \
stepReceiveReturnedPackingList \
stepTic \
stepCheckReceivedReturnedPackingList \
stepDeliverReturnedPackingList \
stepTic \
stepCheckDeliveredReturnedPackingList \
'
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_03_ReturnedSalePackingListWorkflowFail(self, quiet=quiet,
run=run_all_test):
"""
Test that can not change workflow when delivered
"""
if not run: return
sequence_list = SequenceList()
sequence_string = self.default_sequence + '\
stepTic \
stepCreateReturnedPackingList \
stepConfirmReturnedPackingList \
stepTic \
stepCheckConfirmedReturnedPackingList \
stepShipReturnedPackingList \
stepTic \
stepCheckShippedReturnedPackingList \
stepReceiveReturnedPackingList \
stepTic \
stepCheckReceivedReturnedPackingList \
stepDeliverReturnedPackingList \
stepTic \
stepCheckDeliveredReturnedPackingList \
stepTic \
stepConfirmReturnedPackingList \
stepTic \
'
sequence_list.addSequenceString(sequence_string)
try:
sequence_list.play(self, quiet=quiet)
except UnsupportedWorkflowMethod, e:
self.assertTrue(True)
def test_04_ReturnedSalePackingListCreating(self, quiet=quiet,
run=run_all_test):
"""
Test that returned sale packing List creating
"""
if not run: return
sequence_list = SequenceList()
sequence_string = self.default_sequence + '\
stepTic \
stepCreateReturnedPackingList \
stepTic \
stepCheckReturnedPackingListCreating \
'
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_05_ReturnedSalePackingListDeleting(self, quiet=quiet,
run=run_all_test):
"""
Test that returned sale packing list deleting
"""
if not run: return
sequence_list = SequenceList()
sequence_string = self.default_sequence + '\
stepTic \
stepCreateReturnedPackingList \
stepTic \
stepCheckReturnedPackingListDeleting \
'
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_06_ReturnedSalePackingListWithCell(self, quiet=quit,
run=run_all_test):
"""
Test that returned sale packing list with variations
"""
sequence_list = SequenceList()
sequence_string = self.default_sequence + '\
stepTic \
stepCreateReturnedPackingListWithCell \
stepCheckReturnedPackingListWithCell \
'
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_07_ReturnedSalePackingListWithCellDeleting(self, quiet=quit,
run=run_all_test):
"""
Test that deleting variations in returned sale packing list
"""
sequence_list = SequenceList()
sequence_string = self.default_sequence + '\
stepTic \
stepCreateReturnedPackingListWithCell \
stepCheckReturnedPackingListWithCellDeleting \
'
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestReturnedSalePackingList))
return suite
from Products.ERP5Legacy.tests import testLegacySimulationPackingList
from Products.ERP5.tests.testReturnedSalePackingList import *
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7