testDomainTool.py 16.7 KB
Newer Older
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 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
30 31 32

from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
from DateTime import DateTime
33
from AccessControl.SecurityManagement import newSecurityManager
34
from zLOG import LOG
35
from Products.ZSQLCatalog.SQLCatalog import Query
36

37
class TestDomainTool(ERP5TypeTestCase):
38 39 40

  # Different variables used for this test
  run_all_test = 1
41 42 43
  resource_type='Apparel Component'
  resource_variation_type='Apparel Component Variation'
  resource_module = 'apparel_component_module'
44 45 46 47 48 49

  def getTitle(self):
    """
    """
    return "Domain Tool"

50 51 52 53 54
  def enableHotReindexing(self):
    """
    You can override this. Return if we should create (1) or not (0) an activity tool
    """
    return 0
55 56 57 58 59 60

  def getBusinessTemplateList(self):
    """
      Return the list of business templates.

    """
Sebastien Robin's avatar
Sebastien Robin committed
61
    return ('erp5_base','erp5_pdm', 'erp5_trade', 'erp5_apparel')
62 63 64 65

  def getPortalId(self):
    return self.getPortal().getId()

66 67 68
  def getResourceModule(self):
    return getattr(self.getPortal(), self.resource_module, None)

69 70 71 72 73 74 75 76 77
  def afterSetUp(self):
    self.login()

  def login(self, quiet=0):
    uf = self.getPortal().acl_users
    uf._doAddUser('seb', '', ['Manager'], [])
    user = uf.getUserById('seb').__of__(uf)
    newSecurityManager(None, user)

78
  def getSaleOrderModule(self):
79
    return getattr(self.getPortal(),'sale_order_module',None)
80 81 82 83 84

  def getOrderLine(self):
    return self.getSaleOrderModule()['1']['1']

  def getPredicate(self):
85
    return self.getOrganisationModule()['1']
86 87 88

  def createData(self):
    # We have no place to put a Predicate, we will put it in a
89
    # Organisation Module
90 91
    portal = self.getPortal()
    type_tool = self.getTypeTool()
92
    module_type = type_tool['Organisation Module']
93
    module_type.allowed_content_types += ('Mapped Value',)
94
    organisation_module = self.getOrganisationModule()
95 96
    if organisation_module.hasContent('1'):
      organisation_module.deleteContent('1')
97
    predicate = organisation_module.newContent(id='1',portal_type='Mapped Value')
98 99
    predicate.setCriterion('quantity',identity=None,min=None,max=None)
    
100
    resource_module = self.getResourceModule()
101 102
    if resource_module.hasContent('1'):
      resource_module.deleteContent('1')
103
    self.resource = resource = resource_module.newContent(id='1',portal_type=self.resource_type)
104 105
    resource.newContent(id='blue',portal_type=self.resource_variation_type)
    resource.newContent(id='red',portal_type=self.resource_variation_type)
106
    resource.setVariationBaseCategoryList(['variation'])
107 108
    if resource.hasContent('default_supply_line'):
      resource.deleteContent('default_supply_line')
109 110
    self.supply_line = supply_line = resource.newContent(id='default_supply_line',portal_type='Supply Line')

111 112
    # Then create an order with a particular line
    order_module = self.getSaleOrderModule()
113 114 115
    if order_module.hasContent('1'):
      order_module.deleteContent('1')
    order = order_module.newContent(id='1',portal_type='Sale Order')
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
    line = order.newContent(id='1',portal_type='Sale Order Line')

    # Then create a base category
    portal_categories = self.getCategoryTool()
    for bc in ('region', ):
      if not hasattr(portal_categories, bc):
        portal_categories.newContent(portal_type='Base Category',id=bc)
      portal_categories[bc].setAcquisitionMaskValue(1)
      portal_categories[bc].setAcquisitionCopyValue(0)
      portal_categories[bc].setAcquisitionAppendValue(0)
      if not 'europe' in portal_categories[bc].objectIds():
        big_region = portal_categories[bc].newContent(id='europe',portal_type='Category')
      if not 'africa' in portal_categories[bc].objectIds():
        big_region = portal_categories[bc].newContent(id='africa',portal_type='Category')
      if not 'asia' in portal_categories[bc].objectIds():
        big_region = portal_categories[bc].newContent(id='asia',portal_type='Category')
132 133 134

    get_transaction().commit()
    self.tic()
135 136 137 138 139 140 141

  def checkPredicate(self, test=None):

    predicate = self.getPredicate()
    #predicate.setMembershipCriterionBaseCategoryList([])
    #predicate.setMembershipCriterionCategoryList([])
    #predicate.setCriterion('quantity',identity=45,min=None,max=None)
142
    #predicate.immediateReindexObject()
143 144 145 146 147


    order_line = self.getOrderLine()
    domain_tool = self.getDomainTool()

148
    # ignore simulation rules, which are now predicates
149 150 151 152 153
    rule_query = Query(
        operator='AND',
        portal_type=['!=%s' % x for x
          in domain_tool.getPortalRuleTypeList()
          + ('Base Domain', 'Contribution Predicate')])
154

155
    # Test with order line and predicate to none
156 157
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,
        portal_type=rule_query)
158 159 160 161 162
    self.assertEquals(len(predicate_list),1) # Actually, a predicate where
                                             # nothing is defined is ok

    # Test with order line not none and predicate to none
    order_line.setQuantity(45)
163 164
    get_transaction().commit()
    self.tic()
165 166
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,
        portal_type=rule_query)
167 168 169 170
    self.assertEquals(len(predicate_list),1)

    # Test with order line not none and predicate to identity
    order_line.setQuantity(45)
171
    kw = {'portal_type':'Mapped Value'}
172
    predicate.setCriterion('quantity',identity=45,min=None,max=None)
173 174
    get_transaction().commit()
    self.tic()
175
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
176
    self.assertEquals(len(predicate_list),1)
177

178
    order_line.setQuantity(40)
179 180
    get_transaction().commit()
    self.tic()
181
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
182 183 184 185 186 187
    self.assertEquals(len(predicate_list),0)

    # Test with order line not none and predicate to min
    order_line.setQuantity(45)
    predicate = self.getPredicate()
    predicate.setCriterion('quantity',identity=None,min=30,max=None)
188 189
    get_transaction().commit()
    self.tic()
190
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
191
    self.assertEquals(len(predicate_list),1)
192

193
    order_line.setQuantity(10)
194 195
    get_transaction().commit()
    self.tic()
196 197
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,
        portal_type=rule_query)
198 199 200 201 202 203
    self.assertEquals(len(predicate_list),0)

    # Test with order line not none and predicate to max
    order_line.setQuantity(45)
    predicate = self.getPredicate()
    predicate.setCriterion('quantity',identity=None,min=None,max=50)
204 205
    get_transaction().commit()
    self.tic()
206
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
207
    self.assertEquals(len(predicate_list),1)
208

209
    order_line.setQuantity(60)
210 211
    get_transaction().commit()
    self.tic()
212
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
213 214 215 216 217 218
    self.assertEquals(len(predicate_list),0)

    # Test with order line not none and predicate to min max
    order_line.setQuantity(20)
    predicate = self.getPredicate()
    predicate.setCriterion('quantity',identity=None,min=30,max=50)
219 220
    get_transaction().commit()
    self.tic()
221
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
222
    self.assertEquals(len(predicate_list),0)
223

224
    order_line.setQuantity(60)
225 226
    get_transaction().commit()
    self.tic()
227
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
228
    self.assertEquals(len(predicate_list),0)
229

230
    order_line.setQuantity(45)
231
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
232 233
    get_transaction().commit()
    self.tic()
234 235 236 237 238 239
    self.assertEquals(len(predicate_list),1)

    # Test with order line not none and predicate to min max
    # and also predicate to a category
    predicate.setMembershipCriterionBaseCategoryList(['region'])
    predicate.setMembershipCriterionCategoryList(['region/europe'])
240 241
    get_transaction().commit()
    self.tic()
242
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
243
    self.assertEquals(len(predicate_list),0)
244

245
    order_line.setCategoryList(['region/africa'])
246 247
    get_transaction().commit()
    self.tic()
248
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
249
    self.assertEquals(len(predicate_list),0)
250

251
    order_line.setCategoryList(['region/europe'])
252 253
    get_transaction().commit()
    self.tic()
254
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
255
    self.assertEquals(len(predicate_list),1)
256

257
    order_line.setQuantity(60)
258 259
    get_transaction().commit()
    self.tic()
260
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
261 262
    self.assertEquals(len(predicate_list),0)

263 264 265 266 267 268
    # Test with order line not none and predicate to date min and date max
    kw = {'portal_type':'Supply Line'}
    self.supply_line.setBasePrice(23)
    self.supply_line.setPricedQuantity(1)
    self.supply_line.setDefaultResourceValue(self.resource)
    order_line.setDefaultResourceValue(self.resource)
269 270
    self.assertEquals(self.supply_line.getDefaultResourceValue(),self.resource)
    self.assertEquals(order_line.getDefaultResourceValue(),self.resource)
271 272 273 274 275 276
    date1 = DateTime('2005/04/08 10:47:26.388 GMT-4')
    date2 = DateTime('2005/04/10 10:47:26.388 GMT-4')
    self.supply_line.setStartDateRangeMin(date1)
    self.supply_line.setStartDateRangeMax(date2)
    current_date = DateTime('2005/04/1 10:47:26.388 GMT-4')
    order_line.setStartDate(current_date)
277 278
    get_transaction().commit()
    self.tic()
279 280
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
    self.assertEquals(len(predicate_list),0)
281

282 283
    current_date = DateTime('2005/04/09 10:47:26.388 GMT-4')
    order_line.setStartDate(current_date)
284 285
    get_transaction().commit()
    self.tic()
286 287 288
    predicate_list = domain_tool.searchPredicateList(order_line,test=test,**kw)
    self.assertEquals(len(predicate_list),1)

289 290 291 292 293 294 295 296 297 298 299 300 301 302
  def test_01_SearchPredidateListWithNoTest(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      self.logMessage('Search Predicate List With No Test')
    self.createData()
    self.checkPredicate(test=0)

  def test_02_SearchPredidateListWithTest(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      self.logMessage('Search Predicate List With Test')
    self.createData()
    self.checkPredicate(test=1)

303 304 305 306 307
  def test_03_GenerateMappedValue(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      self.logMessage('Generate Mapped Value')
    self.createData()
308
    self.supply_line.setVariationBaseCategoryList(['colour'])
309 310 311
    self.supply_line.setBasePrice(23)
    self.supply_line.setPricedQuantity(1)
    self.supply_line.setDefaultResourceValue(self.resource)
312
    #self.supply_line.setMultimembershipCriterionBaseCategoryList(['resource'])
313
    self.supply_line.setMappedValuePropertyList(['base_price','priced_quantity'])
314
    #self.supply_line.setMembershipCriterionCategoryList(['resource/%s' % self.resource.getRelativeUrl()])
315 316
    get_transaction().commit()
    self.tic()
317 318 319
    domain_tool = self.getDomainTool()
    context = self.resource.asContext(categories=['resource/%s' % self.resource.getRelativeUrl()])
    mapped_value = domain_tool.generateMappedValue(context)
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
    self.assertEquals(mapped_value.getBasePrice(),23)

  def test_04_GenerateMappedValueWithRanges(self, quiet=0, run=run_all_test):
    if not run: return
    if not quiet:
      self.logMessage('Generate Mapped Value With Ranges')
    self.createData()
    self.supply_line.setBasePrice(23)
    self.supply_line.setPricedQuantity(1)
    self.supply_line.setDefaultResourceValue(self.resource)
    date1 = DateTime('2005/04/08')
    date2 = DateTime('2005/04/10')
    self.supply_line.setStartDateRangeMin(date1)
    self.supply_line.setStartDateRangeMax(date2)
    LOG('Test04, supply_line.getStartDateRangeMin',0,self.supply_line.getStartDateRangeMin())
    LOG('Test04, supply_line.getStartDateRangeMax',0,self.supply_line.getStartDateRangeMax())
    self.supply_line.setMappedValuePropertyList(['base_price','priced_quantity'])
337 338
    get_transaction().commit()
    self.tic()
339 340 341 342 343 344 345 346 347 348 349
    domain_tool = self.getDomainTool()
    order_line = self.getOrderLine()
    order_line.setDefaultResourceValue(self.resource)
    current_date = DateTime('2005/04/01')
    order_line.setStartDate(current_date)
    kw = {'portal_type':('Supply Line','Supply Cell')}
    mapped_value = domain_tool.generateMappedValue(order_line,**kw)
    self.assertEquals(mapped_value,None)
    current_date = DateTime('2005/04/09')
    order_line.setStartDate(current_date)
    mapped_value = domain_tool.generateMappedValue(order_line,**kw)
350 351
    self.assertEquals(mapped_value.getBasePrice(),23)

352
  def test_05_GenerateMappedValueWithVariation(self, quiet=0, run=run_all_test):
353 354 355 356
    if not run: return
    if not quiet:
      self.logMessage('Generate Mapped Value With Variation')
    self.createData()
357
    self.supply_line.setVariationBaseCategoryList(['colour'])
358 359 360 361
    self.supply_line.setBasePrice(23)
    self.supply_line.setPricedQuantity(1)
    self.supply_line.setDefaultResourceValue(self.resource)
    self.supply_line.setMappedValuePropertyList(['base_price','priced_quantity'])
362
    self.resource.setPVariationBaseCategoryList(['variation'])
363 364 365
    self.supply_line.updateCellRange(base_id='path')
    cell_range = self.supply_line.SupplyLine_asCellRange()
    for range in cell_range[0]:
366
      cell = self.supply_line.newCell(range,base_id='path',portal_type='Supply Cell')
367 368 369 370 371 372 373 374 375 376 377
      cell.setMappedValuePropertyList(['base_price','priced_quantity'])
      cell.setMultimembershipCriterionBaseCategoryList(['resource','variation'])
      LOG('test, range',0,range)
      cell.setPricedQuantity(1)
      if range.find('blue')>=0:
        cell.setMembershipCriterionCategoryList([range])
        cell.setBasePrice(45)
      if range.find('red')>=0:
        cell.setMembershipCriterionCategoryList([range])
        cell.setBasePrice(26)

378 379 380 381
    right_price_list = [45,26]
    price_list = [x.getBasePrice() for x in self.supply_line.objectValues()]
    self.failIfDifferentSet(price_list,right_price_list)

382 383 384 385 386 387 388 389 390 391 392 393
    def sort_method(x,y):
      # make sure we get cell before
      if hasattr(x,'hasCellContent'):
        x_cell = x.hasCellContent(base_id='path')
        if x_cell:
          return 1
      if hasattr(y,'hasCellContent'):
        y_cell = y.hasCellContent(base_id='path')
        if y_cell:
          return -1
      return 0

394 395
    get_transaction().commit()
    self.tic()
396
    domain_tool = self.getDomainTool()
397 398 399
    context = self.resource.asContext(
                     categories=['resource/%s' % self.resource.getRelativeUrl(),
                     'variation/%s/blue' % self.resource.getRelativeUrl()])
400 401
    mapped_value = domain_tool.generateMappedValue(context,sort_method=sort_method)
    self.assertEquals(mapped_value.getProperty('base_price'),45)
402 403 404
    context = self.resource.asContext(
                     categories=['resource/%s' % self.resource.getRelativeUrl(),
                     'variation/%s/red' % self.resource.getRelativeUrl()])
405 406 407
    mapped_value = domain_tool.generateMappedValue(context,sort_method=sort_method)
    self.assertEquals(mapped_value.getProperty('base_price'),26)
    # Now check the price
408 409 410 411
    self.assertEquals(self.resource.getPrice(context=self.resource.asContext(
                     categories=['resource/%s' % self.resource.getRelativeUrl(),
                     'variation/%s/blue' % self.resource.getRelativeUrl()]),
                     sort_method=sort_method),45)
412

413 414 415 416
def test_suite():
  suite = unittest.TestSuite()
  suite.addTest(unittest.makeSuite(TestDomainTool))
  return suite
417