class WizardMultipleStateChange(testing.OOTestCase):
def setUp(self):
self.txn = Transaction().start(self.database)
self.cursor = self.txn.cursor
self.uid = self.txn.user
def tearDown(self):
self.txn.stop()
def test_multiple_state_change(self):
imd_obj = self.openerp.pool.get('ir.model.data')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
wiz_obj = self.openerp.pool.get('wizard.infoenergia.multiple.state.change')
ctx = {
'active_id': enviament_id, 'active_ids': [enviament_id],
}
vals = {'new_state':'esborrany', 'message':''}
wiz_id = wiz_obj.create(cursor, uid, vals,context=ctx)
wiz_obj.multiple_state_change(cursor, uid, [wiz_id], context=ctx)
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
env_data = env_obj.read(cursor, uid, enviament_id, ['estat', 'info'])
self.assertTrue('Obert -> Esborrany' in env_data['info'])
self.assertEqual('esborrany', env_data['estat'])
class TestPendingStatesData(testing.OOTestCase):
def setUp(self):
self.txn = Transaction().start(self.database)
self.cursor = self.txn.cursor
self.uid = self.txn.user
self.pool = self.openerp.pool
def tearDown(self):
self.txn.stop()
def getref(self, module, reference):
IrModelData = self.pool.get('ir.model.data')
return IrModelData.get_object_reference(
self.cursor, self.uid, module, reference)[1]
def test_dataInserted(self):
id = self.getref('som_account_invoice_pending',
'default_pendent_traspas_advocats_pending_state')
self.assertTrue(id)
PendingState = self.pool.get('account.invoice.pending.state')
pendingState = PendingState.read(self.cursor, self.uid, id, [])
pendingState['process_id']=pendingState['process_id'][1]
assertNsEqual(self, pendingState, """\
id: {id}
active: true
is_last: true
template_id: false
name: Pendent consulta advocats
pending_days: 0
pending_days_type: natural
process_id: Default Process
weight: 1108
""".format(id=id))
class OOTestCaseWithCursor(OOTestCase):
def setUp(self):
self.txn = Transaction().start(self.database)
self.cursor = self.txn.cursor
self.uid = self.txn.user
def tearDown(self):
self.txn.stop()
class OOTestCaseWithCursor(OOTestCase):
def setUp(self):
self.txn = Transaction().start(self.database)
self.cursor = self.txn.cursor
self.uid = self.txn.user
def tearDown(self):
self.txn.stop()
def test__unlink_sms_pending_history__not_factura_reference(self):
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
imd_obj = self.pool.get('ir.model.data')
p_addres_sms = imd_obj.get_object_reference(
cursor, uid, 'powersms', 'sms_outbox_001')[1]
psms_obj = self.pool.get('powersms.smsbox')
psms_obj.write(cursor, uid, [p_addres_sms],
{'reference': 'res.partner.address,1'})
wiz_obj = self.pool.get('wizard.unlink.sms.pending.history')
context = {'active_id': p_addres_sms, 'active_ids': [p_addres_sms]}
wiz_id = wiz_obj.create(cursor, uid, {}, context)
with self.assertRaises(except_osv) as error:
wiz_obj.unlink_sms_pending_history(cursor, uid, [wiz_id],
context)
self.assertEqual(
error.exception.message,
"warning -- Error\n\nS'ha seleccionat algun SMS que no és de factura"
)
self.assertTrue(
psms_obj.search(cursor, uid, [('id', '=', p_addres_sms)]))
def test_set_energetica(self):
contract_obj = self.openerp.pool.get('giscedata.polissa')
imd_obj = self.openerp.pool.get('ir.model.data')
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
contract_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0001'
)[1]
self.set_soci(cursor, uid, contract_id)
# not set
partners_ids = contract_obj.get_bad_energetica_partners(
cursor, uid, contract_id
)
expect(partners_ids).to_not(be_empty)
contract_obj.set_energetica(cursor, uid, contract_id)
# energetica setted
partners_ids = contract_obj.get_bad_energetica_partners(
cursor, uid, contract_id
)
expect(partners_ids).to(be_empty)
def test_all_views(self):
logger.info('Testing views for module %s', self.config['module'])
imd_obj = self.openerp.pool.get('ir.model.data')
view_obj = self.openerp.pool.get('ir.ui.view')
with Transaction().start(self.database) as txn:
imd_ids = imd_obj.search(txn.cursor, txn.user, [
('model', '=', 'ir.ui.view'),
('module', '=', self.config['module'])
])
if imd_ids:
views = {}
for imd in imd_obj.read(txn.cursor, txn.user, imd_ids):
view_xml_name = '{}.{}'.format(imd['module'], imd['name'])
views[imd['res_id']] = view_xml_name
view_ids = views.keys()
logger.info('Testing %s views...', len(view_ids))
for view in view_obj.browse(txn.cursor, txn.user, view_ids):
view_xml_name = views[view.id]
model = self.openerp.pool.get(view.model)
if model is None:
# Check if model exists
raise Exception(
'View (xml id: %s) references model %s which does '
'not exist' % (view_xml_name, view.model)
)
logger.info('Testing view %s (id: %s)', view.name, view.id)
model.fields_view_get(txn.cursor, txn.user, view.id,
view.type)
def test__unlink_sms_pending_history__factura_without_pending_history(
self):
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
imd_obj = self.pool.get('ir.model.data')
fact_obj = self.pool.get('giscedata.facturacio.factura')
p_addres_sms = imd_obj.get_object_reference(
cursor, uid, 'powersms', 'sms_outbox_001')[1]
psms_obj = self.pool.get('powersms.smsbox')
fact_id = imd_obj.get_object_reference(cursor, uid,
'giscedata_facturacio',
'factura_0001')[1]
psms_obj.write(cursor, uid, [p_addres_sms], {
'reference':
'giscedata.facturacio.factura,{}'.format(fact_id)
})
factura = fact_obj.browse(cursor, uid, fact_id)
aiph = factura.pending_history_ids
self.assertFalse(aiph)
wiz_obj = self.pool.get('wizard.unlink.sms.pending.history')
context = {'active_id': p_addres_sms, 'active_ids': [p_addres_sms]}
wiz_id = wiz_obj.create(cursor, uid, {}, context)
wiz_obj.unlink_sms_pending_history(cursor, uid, [wiz_id], context)
self.assertFalse(
psms_obj.search(cursor, uid, [('id', '=', p_addres_sms)]))
def test_bad_energetica_partners(self):
contract_obj = self.openerp.pool.get('giscedata.polissa')
imd_obj = self.openerp.pool.get('ir.model.data')
for field in 'titular', 'pagador', 'altre_p', 'propietari_bank':
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
cat_energetica_id = imd_obj.get_object_reference(
cursor, uid,
'som_energetica', 'res_partner_category_energetica'
)[1]
contract_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0001'
)[1]
self.set_soci(cursor, uid, contract_id)
contract = contract_obj.browse(cursor, uid, contract_id)
field_object = getattr(contract, field)
if not field_object:
continue
if isinstance(field_object, osv.orm.browse_null):
continue
field_object.write(
{'category_id': [(6, 0, [cat_energetica_id])]}
)
partners_ids = contract_obj.get_bad_energetica_partners(
cursor, uid, contract_id
)
expect(partners_ids).to_not(contain(field_object.id))
def test_b2_05_baixa_mailchimp_ok(self, mock_function):
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
self.ResConfig.set(cursor, uid, 'sw_allow_baixa_polissa_from_cn_without_invoice', '1')
contract_id = self.get_contract_id(txn)
# remove all other contracts
old_partner_id = self.Polissa.read(cursor, uid, contract_id, ['titular'])['titular'][0]
pol_ids = self.Polissa.search(cursor, uid,
[('id', '!=', contract_id), ('titular', '=', old_partner_id)])
self.Polissa.write(cursor, uid, pol_ids, {'titular': False})
b2 = self.get_b2_05(txn, contract_id)
with PatchNewCursors():
self.Switching.activa_cas_atr(cursor, uid, b2)
mock_function.assert_called_with(mock.ANY, uid, old_partner_id)
expected_result = u"[Baixa Mailchimp] S'ha iniciat el procés de baixa " \
u"per l'antic titular (ID %d)" % (old_partner_id)
history_line_desc = [
l['description'] for l in b2.history_line
]
self.assertTrue(any([expected_result in desc for desc in history_line_desc]))
def install_module(self, module):
logger.info('Installing module %s', module)
import pooler
from destral.transaction import Transaction
module_obj = self.pool.get('ir.module.module')
with Transaction().start(self.config['db_name']) as txn:
module_obj.update_list(txn.cursor, txn.user)
module_ids = module_obj.search(
txn.cursor,
DEFAULT_USER,
[('name', '=', module)],
)
assert module_ids, "Module %s not found" % module
module_obj.button_install(txn.cursor, DEFAULT_USER, module_ids)
pool = pooler.get_pool(txn.cursor.dbname)
mod_obj = pool.get('ir.module.module')
ids = mod_obj.search(
txn.cursor, txn.user,
[('state', 'in', ['to upgrade', 'to remove', 'to install'])])
unmet_packages = []
mod_dep_obj = pool.get('ir.module.module.dependency')
for mod in mod_obj.browse(txn.cursor, txn.user, ids):
deps = mod_dep_obj.search(txn.cursor, txn.user,
[('module_id', '=', mod.id)])
for dep_mod in mod_dep_obj.browse(txn.cursor, txn.user, deps):
if dep_mod.state in ('unknown', 'uninstalled'):
unmet_packages.append(dep_mod.name)
mod_obj.download(txn.cursor, txn.user, ids)
txn.cursor.commit()
self.db, self.pool = pooler.restart_pool(self.config['db_name'],
update_module=True)
def test_b2_05_baixa_mailchimp_error__active_contract(self, mock_function):
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
self.ResConfig.set(cursor, uid, 'sw_allow_baixa_polissa_from_cn_without_invoice', '0')
contract_id = self.get_contract_id(txn)
# remove all other contracts
old_partner_id = self.Polissa.read(cursor, uid, contract_id, ['titular'])['titular'][0]
pol_ids = self.Polissa.search(cursor, uid,
[('id', '!=', contract_id), ('titular', '=', old_partner_id)])
self.Polissa.write(cursor, uid, pol_ids, {'titular': False})
b2 = self.get_b2_05(txn, contract_id)
with PatchNewCursors():
self.Switching.activa_cas_atr(cursor, uid, b2)
self.assertTrue(not mock_function.called)
expected_result = u"[Baixa Mailchimp] No s\'ha donat de baixa el titular perquè la pòlissa està activa."
history_line_desc = [
l['description'] for l in b2.history_line
]
self.assertTrue(any([expected_result in desc for desc in history_line_desc]))
def test__powersm_send_wizard_save_to_smsbox__empty_numbers(self):
"""
Checks if when create_empty_number = False, and 'to' is empty, the sms is not created
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
model = self.pool.get('powersms.send.wizard')
temp_id = self.imd_obj.get_object_reference(
cursor, uid, 'powersms', 'sms_template_001')[1]
rpa_id = self.imd_obj.get_object_reference(
cursor, uid, 'base', 'res_partner_address_c2c_1')[1]
pca_id = self.imd_obj.get_object_reference(cursor, uid, 'powersms',
'sms_account_001')[1]
vals = {'account': pca_id, 'body_text': 'Test text', 'to': ''}
context = {
'template_id': temp_id,
'rel_model': 'res_partner_address',
'src_rec_ids': [rpa_id],
'active_id': rpa_id,
'active_ids': [rpa_id],
'src_model': 'res.partner.address',
'from': 'Som Energia',
'account': pca_id,
'create_empty_number': False
}
wizard_id = model.create(cursor, uid, vals, context)
wizard_load_n = model.browse(cursor, uid, wizard_id)
sms_created_id = wizard_load_n.save_to_smsbox(context)
self.assertFalse(sms_created_id)
def test_access_rules(self):
"""Test access rules for all the models created in the module
"""
logger.info('Testing access rules for module %s',
self.config['module'])
imd_obj = self.openerp.pool.get('ir.model.data')
access_obj = self.openerp.pool.get('ir.model.access')
no_access = []
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
search_params = [('model', '=', 'ir.model')]
if not self.config.get('all_tests'):
search_params += [('module', '=', self.config['module'])]
imd_ids = imd_obj.search(txn.cursor, txn.user, search_params)
if imd_ids:
for imd in imd_obj.browse(txn.cursor, txn.user, imd_ids):
model_id = imd.res_id
access_ids = access_obj.search(
cursor, uid, [('model_id.id', '=', model_id)])
if not access_ids:
no_access.append('.'.join(imd.name.split('_')[1:]))
if no_access:
self.fail(
"Models: {0} doesn't have any access rules defined".format(
', '.join(no_access)))
def test_ct_traspas_baixa_mailchimp_ok(self, mock_lectures,
mock_mailchimp_function):
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
mock_lectures.return_value = []
contract_id = self.get_contract_id(txn)
# remove all other contracts
old_partner_id = self.Polissa.read(cursor, uid, contract_id,
['titular'])['titular'][0]
pol_ids = self.Polissa.search(cursor, uid,
[('id', '!=', contract_id),
('titular', '=', old_partner_id)])
self.Polissa.write(cursor, uid, pol_ids, {'titular': False})
m1 = self.get_m1_05_traspas(txn, contract_id)
with PatchNewCursors():
self.Switching.activa_cas_atr(cursor, uid, m1)
mock_mailchimp_function.assert_called_with(mock.ANY, uid,
old_partner_id)
expected_result = u"[Baixa Mailchimp] S'ha iniciat el procés de baixa " \
u"per l'antic titular (ID %d)" % (old_partner_id)
history_line_desc = [l['description'] for l in m1.history_line]
self.assertTrue(
any([expected_result in desc for desc in history_line_desc]))
class TestsPartnerAddress(testing.OOTestCase):
def setUp(self):
self.txn = Transaction().start(self.database)
self.cursor, self.uid, self.pool = (self.txn.cursor, self.txn.user,
self.openerp.pool)
def tearDown(self):
self.txn.stop()
def test_fill_merge_fields_clients(self):
partner_address_o = self.pool.get('res.partner.address')
partner_o = self.pool.get('res.partner')
imd_o = self.pool.get('ir.model.data')
address_id = imd_o.get_object_reference(self.cursor, self.uid, 'base',
'res_partner_address_1')[1]
partner_id = partner_address_o.read(self.cursor, self.uid, address_id,
['partner_id'])['partner_id'][0]
municipi_id = imd_o.get_object_reference(self.cursor, self.uid,
'base_extended',
'ine_17160')[1]
partner_address_o.write(self.cursor, self.uid, address_id,
{'id_municipi': municipi_id})
partner_o.write(self.cursor, self.uid, partner_id, {'lang': 'en_US'})
merge_fields = partner_address_o.fill_merge_fields_clients(
self.cursor, self.uid, address_id)
self.maxDiff = None
self.assertDictEqual(
merge_fields, {
'email_address': u'*****@*****.**',
'merge_fields': {
'EMAIL': u'*****@*****.**',
'FNAME': u'OpenRoad',
'LNAME': u'OpenRoad',
'MMERGE10': u'1000',
'MMERGE3': u'en_US',
'MMERGE9': u'OpenRoad',
'MMERGE5': u'Sant Feliu de Gu\xedxols',
'MMERGE6': u'Baix Empord\xe0',
'MMERGE7': u'Girona',
'MMERGE8': u'Catalu\xf1a',
},
'status': 'subscribed'
})
def test__giraVolantEsquerra__Cotxe(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
result = self.Cotxe.giraVolantEsquerra()
def test_facturador_get_tarifa_class(self):
facturador_obj = self.openerp.pool.get(
'giscedata.facturacio.facturador'
)
tarifa_obj = self.openerp.pool.get(
'giscedata.polissa.tarifa'
)
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
contract_obj = self.openerp.pool.get('giscedata.polissa')
imd_obj = self.openerp.pool.get('ir.model.data')
# gets contract 0001
contract_id_index = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0001'
)[1]
contract_id_atr = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0002'
)[1]
# Test all available DSO access fare
for tariff_name in TARIFFS:
tariff_id = tarifa_obj.search(
cursor, uid, [('name', '=', tariff_name)]
)[0]
contract_obj.write(
cursor, uid, [contract_id_index, contract_id_atr],
{'tarifa': tariff_id}
)
contract_index = contract_obj.browse(
cursor, uid, contract_id_index
)
contract_atr = contract_obj.browse(
cursor, uid, contract_id_atr
)
tariff_class_index = facturador_obj.get_tarifa_class(
contract_index
)
tariff_class_atr = facturador_obj.get_tarifa_class(
contract_atr
)
expect(contract_atr.mode_facturacio).to(equal('atr'))
expect(tariff_class_atr).to(be(TARIFFS[tariff_name][0]))
expect(contract_index.mode_facturacio).to(equal('index'))
expect(tariff_class_index).to(be(TARIFFS[tariff_name][1]))
def setUp(self):
fact_obj = self.model('giscedata.facturacio.factura')
line_obj = self.model('giscedata.facturacio.factura.linia')
warn_obj = self.model(
'giscedata.facturacio.validation.warning.template')
self.txn = Transaction().start(self.database)
cursor = self.txn.cursor
uid = self.txn.user
self.malditas_tarifas_contatibles(cursor, uid)
for fact_id in fact_obj.search(cursor, uid, []):
fact_obj.write(cursor, uid, [fact_id], {'state': 'open'})
# We make sure that all warnings are active
warn_ids = warn_obj.search(cursor,
uid, [],
context={'active_test': False})
warn_obj.write(cursor, uid, warn_ids, {'active': True})
def test__giraDreta__Camio(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
with self.assertRaises(AttributeError):
# AttributeError: 'super' object has no attribute 'giraDreta'
result = self.Camio.giraDreta()
def test__giraVolantEsquerra__Camio(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
result = self.Camio.giraVolantEsquerra()
self.assertEquals(result, "Gira el volant del Camió a l'esquerra -> El vehicle gira a l'esquerra")
def test__endarrere__Moto(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
result = self.Moto.endarrere()
self.assertEquals(result, "El vehicle va endarrere -> Un moment, la moto no pot anar endarrere!")
def test__ferHoTot_Moto(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
result = self.Moto.ferhotot()
self.assertEquals(result, "El vehicle va endavant->El vehicle va endarrere -> Un moment, la moto no pot anar endarrere!->El vehicle gira a l'esquerra")
def test__genollEsquerra__Moto(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
result = self.Moto.genollesquerra()
self.assertEquals(result, "El vehicle gira a l'esquerra-> genoll esquerra a terra")
def test__giraVolantEsquerra__Autocar(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
with self.assertRaises(AttributeError):
# AttributeError: 'ClasseAutocar' object has no attribute 'ferhotot'
result = self.Autocar.ferhotot()
def test__obreMaleter__Autocar(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
with self.assertRaises(AttributeError):
# AttributeError: 'ClasseAutocar' object has no attribute 'giraDreta'
result = self.Autocar.obreMaleter()
def test__giraesquerra__Camio(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
# Gràcies al osv.OsvInherits de ClasseCamio, podem accedir als mètodes mare de ClasseVehicle
result = self.Camio.giraesquerra()
self.assertEquals(result, "El vehicle gira a l'esquerra")
def test__parabrises__Camio(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
# Gràcies al osv.OsvInherits de ClasseCamio, podem accedir als mètodes mare
# en aquest cas de la ClasseCotxe, que ha extes el comportament de la ClasseVehicle
result = self.Camio.parabrises()
self.assertEquals(result, "Accionem el parabrises")
class TestAccountAccountSom(testing.OOTestCase):
def model(self, model_name):
return self.openerp.pool.get(model_name)
def setUp(self):
self.txn = Transaction().start(self.database)
self.cursor = self.txn.cursor
self.uid = self.txn.user
def tearDown(self):
self.txn.stop()
def test_saveAccount_withParentRequired(self):
acc_obj = self.openerp.pool.get('account.account')
imd_obj = self.openerp.pool.get('ir.model.data')
view_id = imd_obj.get_object_reference(self.cursor, self.uid,
'account_account_som',
'view_account_form_som')[1]
ac1 = acc_obj.browse(self.cursor, self.uid, 2)
res = acc_obj.fields_view_get(self.cursor,
self.uid,
view_id=view_id,
view_type='form',
context={'active_id': ac1.id})
xml = res['arch']
el = ET.fromstring(xml)
field_list = el.find('group').findall('field')
field_parent = [
field for field in field_list
if field.attrib['name'] == 'parent_id'
]
dictionary = field_parent[0].attrib
assert 'required' in dictionary and dictionary['required'] == 'True'
def test__giraVolantEsquerra__Autocar(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
with self.assertRaises(AttributeError):
# El mètode self.giraesquerra() de dins el mètode giraVolantEsquerra
# de la classe Vehicle no és accessible des de Autocar
# AttributeError: 'super' object has no attribute 'giraesquerra'
result = self.Autocar.giraVolantEsquerra()
def test__powersms_historise__ok(self):
"""
Checks if SMS history is updated
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
psb = self.pool.get('powersms.smsbox')
sms_id = self.imd_obj.get_object_reference(cursor, uid, 'powersms',
'sms_outbox_001')[1]
response = psb.historise(cursor, uid, [sms_id],
u'SMS sent successfully')
history = psb.read(cursor, uid, sms_id, ['history'])
self.assertTrue(u'SMS sent successfully' in history['history'])
def setUp(self):
self.txn = Transaction().start(self.database)
self.cursor = self.txn.cursor
self.uid = self.txn.user
