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_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_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_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__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__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_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_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 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]))
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 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__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 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__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__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__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__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__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")
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__quantresPortesTinc__Autocar(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
#Exemple d'obtenir un element de la base de dades carregat amb el xml demo
autocar_id = self.Data.get_object_reference(
cursor, uid, 'som_herencia', 'demo_autocar_1'
)[1]
result = self.Autocar.quantesPortesTinc(cursor, uid, autocar_id)
self.assertEquals(result, "Tinc 3 portes.")
def test__ferCaballet__Moto(self):
"""
Checks if when state changed, everithing works
:return:
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
#Exemple d'obtenir un element de la base de dades carregat amb el xml demo
moto_id = self.Data.get_object_reference(
cursor, uid, 'som_herencia', 'demo_moto_1'
)[1]
result = self.Moto.fercaballet(cursor, uid, moto_id)
self.assertEquals(result, "Fem el caballet perque tenim molts cavalls -> 30")
def enable_admin(self, password='******'):
from destral.transaction import Transaction
with Transaction().start(self.config['db_name']) as txn:
user_obj = self.pool.get('res.users')
user_ids = user_obj.search(txn.cursor,
txn.user, [('login', '=', 'admin'),
('password', '=', False)],
context={'active_test': False})
if user_ids:
user_obj.write(txn.cursor, txn.user, user_ids, {
'active': True,
'password': password
})
txn.cursor.commit()
logger.info('User admin enabled with password: %s on %s',
password, txn.cursor.dbname)
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 test__powersms_run_sms_scheduler__ok(self, mocked_send, mock_commit):
"""
Checks if run_sms_shceduler is calling async send sms function
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
psb = self.openerp.pool.get('powersms.smsbox')
nsms_outbox_pre = psb.search(cursor, uid,
[('folder', '=', 'outbox')])
nsms_sent_pre = psb.search(cursor, uid, [('folder', '=', 'sent')])
psb.run_sms_scheduler(cursor, uid, {})
mock_commit.assert_called_with()
mocked_send.assert_called_with(cursor, uid, nsms_outbox_pre, {})
def test__passarRevisio_Vehicle(self):
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
vehicle_id = self.Data.get_object_reference(
cursor, uid, 'som_herencia', 'demo_vehicle_1'
)[1]
result = self.Vehicle.passarRevisio(cursor, uid, vehicle_id,False)
vehicle = self.Vehicle.browse(cursor, uid, vehicle_id)
strAvui = str(datetime.today().strftime("%Y-%m-%d"))
self.assertEquals(
result,
"Revisio passada el " + strAvui
)
self.assertEquals(vehicle.data_revisio, strAvui )
def test__get_tariff_prices_invalid_date(self):
"""
Checks that given a tariff and a date there are not prices in that date
:return: warning.
"""
with Transaction().start(self.database) as txn:
cursor = txn.cursor
uid = txn.user
model = self.pool.get('giscedata.polissa.tarifa')
tariff_id = self.imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'tarifa_20A_test')[1]
with self.assertRaises(Exception) as e:
model.get_tariff_prices(cursor, uid, tariff_id, 5386, None,
False, '2020-12-01')
self.assertEqual(e.exception.value, 'Tariff pricelist not found')