openerp/tests/test_ir_sequence.py

   1 # -*- coding: utf-8 -*-
   2 # Run with one of these commands:
   3 #    > OPENERP_ADDONS_PATH='../../addons/trunk' OPENERP_PORT=8069 \
   4 #      OPENERP_DATABASE=yy PYTHONPATH=. python tests/test_ir_sequence.py
   5 #    > OPENERP_ADDONS_PATH='../../addons/trunk' OPENERP_PORT=8069 \
   6 #      OPENERP_DATABASE=yy nosetests tests/test_ir_sequence.py
   7 #    > OPENERP_ADDONS_PATH='../../../addons/trunk' OPENERP_PORT=8069 \
   8 #      OPENERP_DATABASE=yy PYTHONPATH=../:. unit2 test_ir_sequence
   9 # This assume an existing database.
  10 import psycopg2
  11 import psycopg2.errorcodes
  12 import unittest2
  13
  14 import openerp
  15 import common
  16
  17 DB = common.DB
  18 ADMIN_USER_ID = common.ADMIN_USER_ID
  19
  20 def registry(model):
  21     return openerp.modules.registry.RegistryManager.get(DB)[model]
  22
  23 def cursor():
  24     return openerp.modules.registry.RegistryManager.get(DB).db.cursor()
  25
  26
  27 def drop_sequence(code):
  28     cr = cursor()
  29     for model in ['ir.sequence', 'ir.sequence.type']:
  30         s = registry(model)
  31         ids = s.search(cr, ADMIN_USER_ID, [('code', '=', code)])
  32         s.unlink(cr, ADMIN_USER_ID, ids)
  33     cr.commit()
  34     cr.close()
  35
  36 class test_ir_sequence_standard(unittest2.TestCase):
  37     """ A few tests for a 'Standard' (i.e. PostgreSQL) sequence. """
  38
  39     def test_ir_sequence_create(self):
  40         """ Try to create a sequence object. """
  41         cr = cursor()
  42         d = dict(code='test_sequence_type', name='Test sequence type')
  43         c = registry('ir.sequence.type').create(cr, ADMIN_USER_ID, d, {})
  44         assert c
  45         d = dict(code='test_sequence_type', name='Test sequence')
  46         c = registry('ir.sequence').create(cr, ADMIN_USER_ID, d, {})
  47         assert c
  48         cr.commit()
  49         cr.close()
  50
  51     def test_ir_sequence_search(self):
  52         """ Try a search. """
  53         cr = cursor()
  54         ids = registry('ir.sequence').search(cr, ADMIN_USER_ID, [], {})
  55         assert ids
  56         cr.commit()
  57         cr.close()
  58
  59     def test_ir_sequence_draw(self):
  60         """ Try to draw a number. """
  61         cr = cursor()
  62         n = registry('ir.sequence').next_by_code(cr, ADMIN_USER_ID, 'test_sequence_type', {})
  63         assert n
  64         cr.commit()
  65         cr.close()
  66
  67     def test_ir_sequence_draw_twice(self):
  68         """ Try to draw a number from two transactions. """
  69         cr0 = cursor()
  70         cr1 = cursor()
  71         n0 = registry('ir.sequence').next_by_code(cr0, ADMIN_USER_ID, 'test_sequence_type', {})
  72         assert n0
  73         n1 = registry('ir.sequence').next_by_code(cr1, ADMIN_USER_ID, 'test_sequence_type', {})
  74         assert n1
  75         cr0.commit()
  76         cr1.commit()
  77         cr0.close()
  78         cr1.close()
  79
  80     @classmethod
  81     def tearDownClass(cls):
  82         drop_sequence('test_sequence_type')
  83
  84 class test_ir_sequence_no_gap(unittest2.TestCase):
  85     """ Copy of the previous tests for a 'No gap' sequence. """
  86
  87     def test_ir_sequence_create_no_gap(self):
  88         """ Try to create a sequence object. """
  89         cr = cursor()
  90         d = dict(code='test_sequence_type_2', name='Test sequence type')
  91         c = registry('ir.sequence.type').create(cr, ADMIN_USER_ID, d, {})
  92         assert c
  93         d = dict(code='test_sequence_type_2', name='Test sequence',
  94             implementation='no_gap')
  95         c = registry('ir.sequence').create(cr, ADMIN_USER_ID, d, {})
  96         assert c
  97         cr.commit()
  98         cr.close()
  99
 100     def test_ir_sequence_draw_no_gap(self):
 101         """ Try to draw a number. """
 102         cr = cursor()
 103         n = registry('ir.sequence').next_by_code(cr, ADMIN_USER_ID, 'test_sequence_type_2', {})
 104         assert n
 105         cr.commit()
 106         cr.close()
 107
 108     def test_ir_sequence_draw_twice_no_gap(self):
 109         """ Try to draw a number from two transactions.
 110         This is expected to not work.
 111         """
 112         cr0 = cursor()
 113         cr1 = cursor()
 114         cr1._default_log_exceptions = False # Prevent logging a traceback
 115         with self.assertRaises(psycopg2.OperationalError) as e:
 116             n0 = registry('ir.sequence').next_by_code(cr0, ADMIN_USER_ID, 'test_sequence_type_2', {})
 117             assert n0
 118             n1 = registry('ir.sequence').next_by_code(cr1, ADMIN_USER_ID, 'test_sequence_type_2', {})
 119         self.assertEqual(e.exception.pgcode, psycopg2.errorcodes.LOCK_NOT_AVAILABLE, msg="postgresql returned an incorrect errcode")
 120         cr0.close()
 121         cr1.close()
 122
 123     @classmethod
 124     def tearDownClass(cls):
 125         drop_sequence('test_sequence_type_2')
 126
 127 class test_ir_sequence_change_implementation(unittest2.TestCase):
 128     """ Create sequence objects and change their ``implementation`` field. """
 129
 130     def test_ir_sequence_1_create(self):
 131         """ Try to create a sequence object. """
 132         cr = cursor()
 133         d = dict(code='test_sequence_type_3', name='Test sequence type')
 134         c = registry('ir.sequence.type').create(cr, ADMIN_USER_ID, d, {})
 135         assert c
 136         d = dict(code='test_sequence_type_3', name='Test sequence')
 137         c = registry('ir.sequence').create(cr, ADMIN_USER_ID, d, {})
 138         assert c
 139         d = dict(code='test_sequence_type_4', name='Test sequence type')
 140         c = registry('ir.sequence.type').create(cr, ADMIN_USER_ID, d, {})
 141         assert c
 142         d = dict(code='test_sequence_type_4', name='Test sequence',
 143             implementation='no_gap')
 144         c = registry('ir.sequence').create(cr, ADMIN_USER_ID, d, {})
 145         assert c
 146         cr.commit()
 147         cr.close()
 148
 149     def test_ir_sequence_2_write(self):
 150         cr = cursor()
 151         ids = registry('ir.sequence').search(cr, ADMIN_USER_ID,
 152             [('code', 'in', ['test_sequence_type_3', 'test_sequence_type_4'])], {})
 153         registry('ir.sequence').write(cr, ADMIN_USER_ID, ids,
 154             {'implementation': 'standard'}, {})
 155         registry('ir.sequence').write(cr, ADMIN_USER_ID, ids,
 156             {'implementation': 'no_gap'}, {})
 157         cr.commit()
 158         cr.close()
 159
 160     def test_ir_sequence_3_unlink(self):
 161         cr = cursor()
 162         ids = registry('ir.sequence').search(cr, ADMIN_USER_ID,
 163             [('code', 'in', ['test_sequence_type_3', 'test_sequence_type_4'])], {})
 164         registry('ir.sequence').unlink(cr, ADMIN_USER_ID, ids, {})
 165         cr.commit()
 166         cr.close()
 167
 168     @classmethod
 169     def tearDownClass(cls):
 170         drop_sequence('test_sequence_type_3')
 171         drop_sequence('test_sequence_type_4')
 172
 173 class test_ir_sequence_generate(unittest2.TestCase):
 174     """ Create sequence objects and generate some values. """
 175
 176     def test_ir_sequence_create(self):
 177         """ Try to create a sequence object. """
 178         cr = cursor()
 179         d = dict(code='test_sequence_type_5', name='Test sequence type')
 180         c = registry('ir.sequence.type').create(cr, ADMIN_USER_ID, d, {})
 181         assert c
 182         d = dict(code='test_sequence_type_5', name='Test sequence')
 183         c = registry('ir.sequence').create(cr, ADMIN_USER_ID, d, {})
 184         assert c
 185         cr.commit()
 186         cr.close()
 187
 188         cr = cursor()
 189         f = lambda *a: registry('ir.sequence').next_by_code(cr, ADMIN_USER_ID, 'test_sequence_type_5', {})
 190         assert all(str(x) == f() for x in xrange(1,10))
 191         cr.commit()
 192         cr.close()
 193
 194     def test_ir_sequence_create_no_gap(self):
 195         """ Try to create a sequence object. """
 196         cr = cursor()
 197         d = dict(code='test_sequence_type_6', name='Test sequence type')
 198         c = registry('ir.sequence.type').create(cr, ADMIN_USER_ID, d, {})
 199         assert c
 200         d = dict(code='test_sequence_type_6', name='Test sequence')
 201         c = registry('ir.sequence').create(cr, ADMIN_USER_ID, d, {})
 202         assert c
 203         cr.commit()
 204         cr.close()
 205
 206         cr = cursor()
 207         f = lambda *a: registry('ir.sequence').next_by_code(cr, ADMIN_USER_ID, 'test_sequence_type_6', {})
 208         assert all(str(x) == f() for x in xrange(1,10))
 209         cr.commit()
 210         cr.close()
 211
 212     @classmethod
 213     def tearDownClass(cls):
 214         drop_sequence('test_sequence_type_5')
 215         drop_sequence('test_sequence_type_6')
 216
 217
 218 if __name__ == '__main__':
 219     unittest2.main()
 220
 221
 222 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: