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()
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'
})
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'
class TestsAutoActiva(testing.OOTestCase):
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 tearDown(self):
self.txn.stop()
def malditas_tarifas_contatibles(self, cursor, uid):
"""
Hace a todas las tarifas compatibles con todas las listas de
precios
"""
tarif_obj = self.openerp.pool.get('giscedata.polissa.tarifa')
tarifas_ids = tarif_obj.search(cursor, uid, [])
pricelist_obj = self.openerp.pool.get('product.pricelist')
pricelists_ids = pricelist_obj.search(cursor, uid, [])
tarif_obj.write(
cursor, uid, tarifas_ids,
{'llistes_preus_comptatibles': [(6, 0, pricelists_ids)]})
def model(self, model_name):
return self.openerp.pool.get(model_name)
def change_polissa_comer(self, txn):
cursor = txn.cursor
uid = txn.user
imd_obj = self.openerp.pool.get('ir.model.data')
new_comer_id = imd_obj.get_object_reference(cursor, uid, 'base',
'res_partner_c2c')[1]
pol_obj = self.openerp.pool.get('giscedata.polissa')
pol_id = imd_obj.get_object_reference(cursor, uid, 'giscedata_polissa',
'polissa_0001')[1]
pol_obj.write(cursor, uid, [pol_id],
{'comercialitzadora': new_comer_id})
def update_polissa_distri(self, txn):
"""
Sets the distribuidora_id field in contract as the same of related cups
"""
cursor = txn.cursor
uid = txn.user
imd_obj = self.openerp.pool.get('ir.model.data')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cups_obj = self.openerp.pool.get('giscedata.cups.ps')
contract_id = imd_obj.get_object_reference(cursor, uid,
'giscedata_polissa',
'polissa_0001')[1]
cups_id = pol_obj.read(cursor, uid, contract_id, ['cups'])['cups'][0]
distri_id = cups_obj.read(cursor, uid, cups_id,
['distribuidora_id'])['distribuidora_id'][0]
pol_obj.write(cursor, uid, contract_id, {'distribuidora': distri_id})
@mock.patch(
'giscedata_switching.giscedata_switching.GiscedataSwitching.whereiam')
def switch(self,
txn,
where,
mock_function,
is_autocons=False,
other_id_name='res_partner_agrolait'):
cursor = txn.cursor
uid = txn.user
mock_function.return_value = where
imd_obj = self.openerp.pool.get('ir.model.data')
partner_obj = self.openerp.pool.get('res.partner')
cups_obj = self.openerp.pool.get('giscedata.cups.ps')
partner_id = imd_obj.get_object_reference(cursor, uid, 'base',
'main_partner')[1]
other_id = imd_obj.get_object_reference(cursor, uid, 'base',
other_id_name)[1]
another_id = imd_obj.get_object_reference(cursor, uid, 'base',
'res_partner_c2c')[1]
if is_autocons:
codes = {'distri': '4321', 'comer': '1234'}
else:
codes = {'distri': '1234', 'comer': '4321'}
partner_obj.write(cursor, uid, [partner_id], {'ref': codes.pop(where)})
partner_obj.write(cursor, uid, [other_id], {'ref': codes.values()[0]})
partner_obj.write(cursor, uid, [another_id], {'ref': '5555'})
cups_id = imd_obj.get_object_reference(cursor, uid, 'giscedata_cups',
'cups_01')[1]
distri_ids = {'distri': partner_id, 'comer': other_id}
cups_obj.write(cursor, uid, [cups_id],
{'distribuidora_id': distri_ids[where]})
cache.clean_caches_for_db(cursor.dbname)
def create_case_and_step(self,
cursor,
uid,
contract_id,
proces_name,
step_name,
sw_id_origin=None,
context=None):
"""
Creates case and step
:param proces_name:
:param step_name:
:param context:
:return:
"""
if context is None:
context = {}
if isinstance(sw_id_origin, dict):
context = sw_id_origin
sw_id_origin = None
sw_obj = self.openerp.pool.get('giscedata.switching')
swproc_obj = self.openerp.pool.get('giscedata.switching.proces')
swpas_obj = self.openerp.pool.get('giscedata.switching.step')
swinfo_obj = self.openerp.pool.get('giscedata.switching.step.info')
contract_obj = self.openerp.pool.get('giscedata.polissa')
proces_id = swproc_obj.search(cursor, uid,
[('name', '=', proces_name)])[0]
sw_params = {
'proces_id': proces_id,
'cups_polissa_id': contract_id,
}
vals = sw_obj.onchange_polissa_id(cursor,
uid, [],
contract_id,
None,
context=context)
sw_params.update(vals['value'])
# si no tenim ref_contracte, ens l'inventem (de moment)
if not sw_params.get('ref_contracte', False):
sw_params['ref_contracte'] = '111111111'
if sw_id_origin:
sw_id = sw_id_origin
else:
sw_id = sw_obj.create(cursor, uid, sw_params)
if proces_name in ['C1', 'C2']:
out_retail = contract_obj.read(
cursor, uid, contract_id,
['comercialitzadora'])['comercialitzadora'][0]
sw_obj.write(cursor, uid, sw_id, {'comer_sortint_id': out_retail})
# creeem el pas
pas_id = swpas_obj.get_step(cursor, uid, step_name, proces_name)
#Creant info ja crea automaticament tota la info del pas
info_vals = {
'sw_id': sw_id,
'proces_id': proces_id,
'step_id': pas_id,
}
info_id = swinfo_obj.create(cursor, uid, info_vals, context=context)
info = swinfo_obj.browse(cursor, uid, info_id)
model_obj, model_id = info.pas_id.split(',')
return int(model_id)
def get_contract_id(self, txn, xml_id='polissa_0001'):
uid = txn.user
cursor = txn.cursor
imd_obj = self.openerp.pool.get('ir.model.data')
return imd_obj.get_object_reference(cursor, uid, 'giscedata_polissa',
xml_id)[1]
def create_complete_case(self,
polissa_id,
case,
step,
status,
substep=None):
class TestWizardAccountBalance(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_get_account_balance_wiz_data_ok(self):
cursor = self.cursor
uid = self.uid
wiz_obj = self.openerp.pool.get('wizard.account.balance.report')
imd_obj = self.openerp.pool.get('ir.model.data')
aa_obj = self.openerp.pool.get('account.account')
account_list = aa_obj.search(cursor, uid, [])
menu_id = imd_obj.get_object_reference(
cursor, uid, 'account_account_som',
'menu_account_balance_full_report_som')[1]
values = {
'date_from': '2021-01-01',
'display_account_level': 0,
'company_id': 1,
'state': 'none',
'all_accounts': 1,
'periods': [(6, 0, [])],
'date_to': '2021-12-17',
'account_list': [(6, 0, [])],
'display_account': 'bal_all',
'fiscalyear': 1
}
context = {
'lang': False,
'active_ids': [menu_id],
'tz': False,
'active_id': menu_id
}
wiz_id = wiz_obj.create(cursor, uid, values, context)
wiz = wiz_obj.browse(cursor, uid, wiz_id)
datas = wiz.get_account_balance_wiz_data(context)
self.assertEqual(
datas, {
'form': {
'date_from': '2021-01-01',
'display_account_level': 0,
'company_id': 1,
'state': 'none',
'all_accounts': 1,
'periods': [(6, 0, [])],
'date_to': '2021-12-17',
'account_list': [(6, 0, account_list)],
'display_account': 'bal_all',
'fiscalyear': 1,
'context': {
'lang': False,
'active_ids': [menu_id],
'tz': False,
'active_id': menu_id
}
}
})
@mock.patch('async_reports.async_reports.AsyncReports.waiting_report')
def test_wizard_account_balance_report_async(self, mock_waiting_report):
cursor = self.cursor
uid = self.uid
wiz_obj = self.openerp.pool.get('wizard.account.balance.report')
imd_obj = self.openerp.pool.get('ir.model.data')
aa_obj = self.openerp.pool.get('account.account')
account_list = aa_obj.search(cursor, uid, [])
menu_id = imd_obj.get_object_reference(
cursor, uid, 'account_account_som',
'menu_account_balance_full_report_som')[1]
values = {
'date_from': '2021-01-01',
'display_account_level': 0,
'company_id': 1,
'state': 'none',
'all_accounts': True,
'periods': [(6, 0, [])],
'date_to': '2021-12-17',
'account_list': [(6, 0, [])],
'display_account': 'bal_all',
'fiscalyear': 1,
}
context = {
'lang': False,
'active_ids': [menu_id],
'tz': False,
'active_id': menu_id
}
wiz_id = wiz_obj.create(cursor, uid, values, context)
wiz = wiz_obj.browse(cursor, uid, wiz_id)
result = wiz._report_async(context)
expected_datas = {
'form': {
'date_from': '2021-01-01',
'display_account_level': 0,
'company_id': 1,
'state': 'none',
'all_accounts': True,
'periods': [(6, 0, [])],
'date_to': '2021-12-17',
'account_list': [[6, 0, account_list]],
'display_account': 'bal_all',
'fiscalyear': 1,
'context': {
'lang': False,
'active_ids': [menu_id],
'tz': False,
'active_id': menu_id
}
},
'email_to': '*****@*****.**',
'from': 1,
}
mock_waiting_report.assert_called_with(mock.ANY, mock.ANY, [wiz_id],
'account.balance.full',
expected_datas, context)
self.assertTrue(result)
class WizardCancelFromCSVTestsAndAddContractsLot(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_wizard_invalid_active_id__exception_raises(self):
imd_obj = self.openerp.pool.get('ir.model.data')
cursor = self.cursor
uid = self.uid
wiz_obj = self.openerp.pool.get('wizard.infoenergia.add.contracts.lot')
wiz_id = wiz_obj.create(cursor, uid, {},{})
with self.assertRaises(osv.osv.except_osv) as e:
wiz_obj.add_contracts_lot(cursor, uid, [wiz_id], {})
self.assertEqual(e.exception.value, "S'ha de seleccionar un lot")
wiz_id = wiz_obj.create(cursor, uid, {},{})
with self.assertRaises(osv.osv.except_osv) as e:
wiz_obj.add_contracts_lot(cursor, uid, [wiz_id], {'active_ids': [wiz_id, 2]})
self.assertEqual(e.exception.value, "S'ha de seleccionar un lot")
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_wizard_invalid_active_id__access_fare(self, mocked_create_enviaments_from_object_list):
imd_obj = self.openerp.pool.get('ir.model.data')
cursor = self.cursor
uid = self.uid
wiz_obj = self.openerp.pool.get('wizard.infoenergia.add.contracts.lot')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
expected_ids = pol_obj.search(cursor, uid, [('tarifa','ilike','%2.0%')])
context = {'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id]}
wiz_id = wiz_obj.create(
cursor, uid, {'access_fare':'2.0'},
context=context
)
wiz_obj.add_contracts_lot(cursor, uid, [wiz_id], context)
mocked_create_enviaments_from_object_list.assert_called_with(cursor, uid, lot_enviament_id, expected_ids, {'from_model': 'polissa_id'})
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_wizard_invalid_active_id__invalid_cateogry(self, mocked_create_enviaments_from_object_list):
imd_obj = self.openerp.pool.get('ir.model.data')
cursor = self.cursor
uid = self.uid
wiz_obj = self.openerp.pool.get('wizard.infoenergia.add.contracts.lot')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
context = {'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id]}
wiz_id = wiz_obj.create(
cursor, uid, {'category':'InexistantCategory'},
context=context
)
wiz_obj.add_contracts_lot(cursor, uid, [wiz_id], context)
mocked_create_enviaments_from_object_list.assert_called_with(cursor, uid, lot_enviament_id, [], {'from_model': 'polissa_id'})
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_wizard_invalid_active_id__no_filters(self, mocked_create_enviaments_from_object_list):
imd_obj = self.openerp.pool.get('ir.model.data')
cursor = self.cursor
uid = self.uid
wiz_obj = self.openerp.pool.get('wizard.infoenergia.add.contracts.lot')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
expected_ids = pol_obj.search(cursor, uid, [])
context = {'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id]}
wiz_id = wiz_obj.create(
cursor, uid, {},
context=context
)
wiz_obj.add_contracts_lot(cursor, uid, wiz_id, context)
mocked_create_enviaments_from_object_list.assert_called_with(cursor, uid, lot_enviament_id, expected_ids, {'from_model': 'polissa_id'})
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.cancel_enviaments_from_polissa_names')
def test_cancel_from_csv__one(self, mock_cancel):
wiz_obj = self.openerp.pool.get('wizard.cancel.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
csv_content = "0001"
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
'reason': 'Test'
}
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
env_ids = env_obj.search(self.cursor, self.uid, [('lot_enviament', '=', lot_enviament_id), ('polissa_id.name', '=', '0001')])
wiz_id = wiz_obj.create(self.cursor, self.uid, vals,context=ctx)
wiz_obj.cancel_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_cancel.assert_called_with(self.cursor, self.uid, lot_enviament_id, ["0001"], ctx)
self.assertTrue(
"Cancel·lats enviaments des de CSV amb 1 línies"
in lot_env_obj.read(self.cursor, self.uid, lot_enviament_id, ['info'])['info']
)
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.cancel_enviaments_from_polissa_names')
def test_cancel_from_csv__many(self, mock_cancel):
wiz_obj = self.openerp.pool.get('wizard.cancel.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
csv_content = "0001\n0002"
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
'reason': 'Test'
}
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
env_ids = env_obj.search(self.cursor, self.uid, [('lot_enviament', '=', lot_enviament_id), ('polissa_id.name', '=', '0001')])
wiz_id = wiz_obj.create(self.cursor, self.uid, vals,context=ctx)
wiz_obj.cancel_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_cancel.assert_called_with(self.cursor, self.uid, lot_enviament_id, ["0001", "0002"], ctx)
self.assertTrue(
"Cancel·lats enviaments des de CSV amb 2 línies"
in lot_env_obj.read(self.cursor, self.uid, lot_enviament_id, ['info'])['info']
)
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_create_enviaments_from_csv__infoenergia_none(self, mock_create):
wiz_obj = self.openerp.pool.get('wizard.create.enviaments.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
csv_content = ""
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
}
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
wiz_id = wiz_obj.create(self.cursor, self.uid, vals, context=ctx)
wiz_obj.create_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_create.assert_called_with(self.cursor, self.uid, lot_enviament_id, [], {'from_model': 'polissa_id'})
wiz_info = wiz_obj.read(self.cursor, self.uid, [wiz_id], ['info'])[0]['info']
self.assertEqual(wiz_info, "Es crearan els enviaments de 0 pòlisses en segon pla")
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_create_enviaments_from_csv__infoenergia_one(self, mock_create):
wiz_obj = self.openerp.pool.get('wizard.create.enviaments.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
pol_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0002'
)[1]
pol_name = pol_obj.read(self.cursor, self.uid, pol_id, ['name'])['name']
csv_content = "{}".format(pol_name)
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
}
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
wiz_id = wiz_obj.create(self.cursor, self.uid, vals, context=ctx)
wiz_obj.create_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_create.assert_called_with(self.cursor, self.uid, lot_enviament_id, [pol_id], {'from_model': 'polissa_id'})
wiz_info = wiz_obj.read(self.cursor, self.uid, [wiz_id], ['info'])[0]['info']
self.assertEqual(wiz_info, "Es crearan els enviaments de 1 pòlisses en segon pla")
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_create_enviaments_from_csv__infoenergia_many(self, mock_create):
wiz_obj = self.openerp.pool.get('wizard.create.enviaments.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
pol_id_2 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0002'
)[1]
pol_id_3 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0003'
)[1]
pol_name_2 = pol_obj.read(self.cursor, self.uid, pol_id_2, ['name'])['name']
pol_name_3 = pol_obj.read(self.cursor, self.uid, pol_id_3, ['name'])['name']
csv_content = "{}\n{}".format(pol_name_2, pol_name_3)
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
}
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
wiz_id = wiz_obj.create(self.cursor, self.uid, vals, context=ctx)
wiz_obj.create_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_create.assert_called_with(self.cursor, self.uid, lot_enviament_id, [pol_id_2, pol_id_3], {'from_model': 'polissa_id'})
wiz_info = wiz_obj.read(self.cursor, self.uid, [wiz_id], ['info'])[0]['info']
self.assertEqual(wiz_info, "Es crearan els enviaments de 2 pòlisses en segon pla")
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_create_enviaments_from_csv__massive_extra_info(self, mock_create):
wiz_obj = self.openerp.pool.get('wizard.create.enviaments.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
pol_id_2 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0002'
)[1]
pol_id_3 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0003'
)[1]
pol_name_2 = pol_obj.read(self.cursor, self.uid, pol_id_2, ['name'])['name']
pol_name_3 = pol_obj.read(self.cursor, self.uid, pol_id_3, ['name'])['name']
csv_content = "polissa,extra_info,k\n{},Info 1,234\n{},Info 2,213".format(pol_name_2, pol_name_3)
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
}
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
wiz_id = wiz_obj.create(self.cursor, self.uid, vals, context=ctx)
wiz_obj.create_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_create.assert_called_with(self.cursor, self.uid, lot_enviament_id, [pol_id_2, pol_id_3],
{'from_model': 'polissa_id', 'extra_text': {'0002': {'k': '234', 'extra_info': 'Info 1'},
'0003': {'k': '213', 'extra_info': 'Info 2'}}})
wiz_info = wiz_obj.read(self.cursor, self.uid, [wiz_id], ['info'])[0]['info']
self.assertEqual(wiz_info, "Es crearan els enviaments de 2 pòlisses en segon pla")
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_create_enviaments_from_csv__massive_extra_info(self, mock_create):
wiz_obj = self.openerp.pool.get('wizard.create.enviaments.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
pol_id_2 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0002'
)[1]
pol_id_3 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0003'
)[1]
pol_name_2 = pol_obj.read(self.cursor, self.uid, pol_id_2, ['name'])['name']
pol_name_3 = pol_obj.read(self.cursor, self.uid, pol_id_3, ['name'])['name']
csv_content = "polissa,extra_info,k\n{},Info 1,234\n{},Info 2,213".format(pol_name_2, pol_name_3)
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
}
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
wiz_id = wiz_obj.create(self.cursor, self.uid, vals, context=ctx)
wiz_obj.create_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_create.assert_called_with(self.cursor, self.uid, lot_enviament_id, [pol_id_2, pol_id_3],
{'from_model': 'polissa_id', 'extra_text': {'0002': {'k': '234', 'extra_info': 'Info 1'},
'0003': {'k': '213', 'extra_info': 'Info 2'}}})
wiz_info = wiz_obj.read(self.cursor, self.uid, [wiz_id], ['info'])[0]['info']
self.assertEqual(wiz_info, "Es crearan els enviaments de 2 pòlisses en segon pla")
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_create_enviaments_from_csv__massive_extra_info_without_header(self, mock_create):
wiz_obj = self.openerp.pool.get('wizard.create.enviaments.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
pol_id_2 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0002'
)[1]
pol_id_3 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0003'
)[1]
pol_name_2 = pol_obj.read(self.cursor, self.uid, pol_id_2, ['name'])['name']
pol_name_3 = pol_obj.read(self.cursor, self.uid, pol_id_3, ['name'])['name']
csv_content = "{},Info 1,234\n{},Info 2,213".format(pol_name_2, pol_name_3)
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
}
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
wiz_id = wiz_obj.create(self.cursor, self.uid, vals, context=ctx)
wiz_obj.create_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_create.assert_called_with(self.cursor, self.uid, lot_enviament_id, [pol_id_2, pol_id_3],
{'from_model': 'polissa_id'})
wiz_info = wiz_obj.read(self.cursor, self.uid, [wiz_id], ['info'])[0]['info']
self.assertEqual(wiz_info, "Es crearan els enviaments de 2 pòlisses en segon pla")
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_object_list')
def test_create_enviaments_from_csv__massive_extra_info_with_semicolon(self, mock_create):
wiz_obj = self.openerp.pool.get('wizard.create.enviaments.from.csv')
imd_obj = self.openerp.pool.get('ir.model.data')
pol_obj = self.openerp.pool.get('giscedata.polissa')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
lot_enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
pol_id_2 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0002'
)[1]
pol_id_3 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_polissa', 'polissa_0003'
)[1]
pol_name_2 = pol_obj.read(self.cursor, self.uid, pol_id_2, ['name'])['name']
pol_name_3 = pol_obj.read(self.cursor, self.uid, pol_id_3, ['name'])['name']
csv_content = "polissa;extra_info;k\n{};Info 1;234\n{};Info 2;213".format(pol_name_2, pol_name_3)
encoded_csv = base64.b64encode(csv_content)
vals = {
'csv_file': encoded_csv,
}
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
}
wiz_id = wiz_obj.create(self.cursor, self.uid, vals, context=ctx)
wiz_obj.create_from_file(self.cursor, self.uid, [wiz_id], context=ctx)
mock_create.assert_called_with(self.cursor, self.uid, lot_enviament_id, [pol_id_2, pol_id_3],
{'from_model': 'polissa_id', 'extra_text': {'0002': {'k': '234', 'extra_info': 'Info 1'},
'0003': {'k': '213', 'extra_info': 'Info 2'}}})
wiz_info = wiz_obj.read(self.cursor, self.uid, [wiz_id], ['info'])[0]['info']
self.assertEqual(wiz_info, "Es crearan els enviaments de 2 pòlisses en segon pla")
class WizardSendReportsTests(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()
@mock.patch('som_infoenergia.som_infoenergia_enviament.SomInfoenergiaEnviament.send_reports')
def test_send_reports_from_lot(self, mocked_send_reports):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
env_ids = env_obj.search(cursor, uid, [('lot_enviament','=', lot_enviament_id)])
wiz_obj = self.openerp.pool.get('wizard.infoenergia.send.reports')
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
'from_model':'som.infoenergia.lot.enviament'
}
wiz_id = wiz_obj.create(cursor, uid, {},context=ctx)
wiz_obj.send_reports(cursor, uid, [wiz_id], context=ctx)
mocked_send_reports.assert_called_with(cursor, uid, env_ids, context={'allow_reenviar':False})
@mock.patch('som_infoenergia.som_infoenergia_enviament.SomInfoenergiaEnviament.send_reports')
def test_send_reports_from_enviament(self, mocked_send_reports):
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.send.reports')
ctx = {
'active_id': enviament_id, 'active_ids': [enviament_id],
'from_model':'som.infoenergia.enviament'
}
wiz_id = wiz_obj.create(cursor, uid, {},context=ctx)
wiz_obj.send_reports(cursor, uid, [wiz_id], context=ctx)
mocked_send_reports.assert_called_with(cursor, uid, [enviament_id], context={'allow_reenviar':False})
@mock.patch('som_infoenergia.som_infoenergia_enviament.SomInfoenergiaEnviament.send_reports')
def test_send_reports_from_test_lot_missing_email(self, mocked_send_reports):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
lot_env_obj.write(cursor, uid, lot_enviament_id, {'is_test': True})
wiz_obj = self.openerp.pool.get('wizard.infoenergia.send.reports')
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
'from_model':'som.infoenergia.lot.enviament'
}
wiz_id = wiz_obj.create(cursor, uid, {},context=ctx)
with self.assertRaises(osv.osv.except_osv) as error_email:
wiz_obj.send_reports(cursor, uid, [wiz_id], context=ctx)
self.assertEqual(error_email.exception.value, "Cal indicar l'email destinatari de l'enviament")
mocked_send_reports.assert_not_called()
@mock.patch('som_infoenergia.som_infoenergia_enviament.SomInfoenergiaEnviament.send_reports')
def test_send_reports_from_test_lot(self, mocked_send_reports):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
lot_env_obj.write(cursor, uid, lot_enviament_id, {'is_test': True})
env_ids = env_obj.search(cursor, uid, [('lot_enviament','=', lot_enviament_id)])
wiz_obj = self.openerp.pool.get('wizard.infoenergia.send.reports')
ctx = {
'active_id': lot_enviament_id, 'active_ids': [lot_enviament_id],
'from_model':'som.infoenergia.lot.enviament'
}
vals = {
'email_to':'*****@*****.**', 'email_subject':'TEST',
'allow_reenviar':False
}
wiz_id = wiz_obj.create(cursor, uid, vals.copy(),context=ctx)
wiz_obj.send_reports(cursor, uid, [wiz_id], context=ctx)
mocked_send_reports.assert_called_with(cursor, uid, env_ids, context=vals)
class TestMultipleCommentF1(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 test__multiple_comment_F1__oneF1(self):
"""
Test per afegir un comentari en una sola F1
"""
imd_obj = self.pool.get('ir.model.data')
wiz_o = self.pool.get('wizard.comment.to.F1')
inv_o = self.pool.get("giscedata.facturacio.importacio.linia")
inv_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_facturacio_switching',
'line_02_f1_import_01')[1]
wiz_init = {'comment': ''}
wiz_id = wiz_o.create(self.cursor,
self.uid,
wiz_init,
context={
'active_ids': [inv_id],
'from_model':
'giscedata.facturacio.importacio.linia'
})
wiz_o.write(self.cursor, self.uid, [wiz_id],
{'comment': 'comentari test 1'})
wiz_o.modify_text_F1(
self.cursor, self.uid, [wiz_id], {
'active_ids': [inv_id],
'from_model': 'giscedata.facturacio.importacio.linia'
})
new_comment = inv_o.read(self.cursor, self.uid, inv_id,
['user_observations'])['user_observations']
self.assertEqual(new_comment, 'comentari test 1\n')
def test__multiple_comment_to_F1__manyF1(self):
"""
Test per afegir un comentari en més d'una F1
"""
imd_obj = self.pool.get('ir.model.data')
wiz_o = self.pool.get('wizard.comment.to.F1')
inv_o = self.pool.get("giscedata.facturacio.importacio.linia")
inv_id_1 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_facturacio_switching',
'line_02_f1_import_01')[1]
inv_id_2 = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_facturacio_switching',
'line_03_f1_import_01')[1]
wiz_init = {'comment': ''}
wiz_id = wiz_o.create(self.cursor,
self.uid,
wiz_init,
context={
'active_ids': [inv_id_1, inv_id_2],
'from_model':
'giscedata.facturacio.importacio.linia'
})
wiz_o.write(self.cursor, self.uid, [wiz_id],
{'comment': 'comentari test 1'})
wiz_o.modify_text_F1(
self.cursor, self.uid, [wiz_id], {
'active_ids': [inv_id_1, inv_id_2],
'from_model': 'giscedata.facturacio.importacio.linia'
})
new_comment_1 = inv_o.read(self.cursor, self.uid, inv_id_1,
['user_observations'])['user_observations']
new_comment_2 = inv_o.read(self.cursor, self.uid, inv_id_2,
['user_observations'])['user_observations']
self.assertEqual(new_comment_1, 'comentari test 1\n')
self.assertEqual(new_comment_2, 'comentari test 1\n')
def test__multiple_comment_to_F1__appendComment(self):
"""
Test per afegir un comentari en una sola F1
"""
imd_obj = self.pool.get('ir.model.data')
wiz_o = self.pool.get('wizard.comment.to.F1')
inv_o = self.pool.get("giscedata.facturacio.importacio.linia")
inv_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_facturacio_switching',
'line_02_f1_import_01')[1]
inv_o.write(self.cursor, self.uid, inv_id,
{'user_observations': 'comentari test 2'})
wiz_init = {'comment': ''}
wiz_id = wiz_o.create(self.cursor,
self.uid,
wiz_init,
context={
'active_ids': [inv_id],
'from_model':
'giscedata.facturacio.importacio.linia'
})
wiz_o.write(self.cursor, self.uid, [wiz_id],
{'comment': 'comentari test 1'})
wiz_o.modify_text_F1(
self.cursor, self.uid, [wiz_id], {
'active_ids': [inv_id],
'from_model': 'giscedata.facturacio.importacio.linia'
})
new_comment = inv_o.read(self.cursor, self.uid, inv_id,
['user_observations'])['user_observations']
self.assertEqual(new_comment, 'comentari test 1\ncomentari test 2')
def test__multiple_comment_to_F1__replaceComment(self):
"""
Test per afegir un comentari en una sola F1
"""
imd_obj = self.pool.get('ir.model.data')
wiz_o = self.pool.get('wizard.comment.to.F1')
inv_o = self.pool.get("giscedata.facturacio.importacio.linia")
inv_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_facturacio_switching',
'line_02_f1_import_01')[1]
inv_o.write(self.cursor, self.uid, inv_id,
{'user_observations': 'comentari test 2'})
wiz_init = {'comment': 'comentari test 1', 'option': 'substituir'}
wiz_id = wiz_o.create(self.cursor,
self.uid,
wiz_init,
context={
'active_ids': [inv_id],
'from_model':
'giscedata.facturacio.importacio.linia'
})
wiz_o.modify_text_F1(
self.cursor, self.uid, [wiz_id], {
'active_ids': [inv_id],
'from_model': 'giscedata.facturacio.importacio.linia'
})
new_comment = inv_o.read(self.cursor, self.uid, inv_id,
['user_observations'])['user_observations']
self.assertEqual(new_comment, 'comentari test 1')
def test__multiple_comment_to_F1__deleteComment(self):
"""
Test per afegir un comentari en una sola F1
"""
imd_obj = self.pool.get('ir.model.data')
wiz_o = self.pool.get('wizard.comment.to.F1')
inv_o = self.pool.get("giscedata.facturacio.importacio.linia")
inv_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'giscedata_facturacio_switching',
'line_02_f1_import_01')[1]
inv_o.write(self.cursor, self.uid, inv_id,
{'user_observations': 'comentari test 2'})
wiz_init = {'comment': '', 'option': 'eliminar'}
wiz_id = wiz_o.create(self.cursor,
self.uid,
wiz_init,
context={
'active_ids': [inv_id],
'from_model':
'giscedata.facturacio.importacio.linia'
})
wiz_o.modify_text_F1(
self.cursor, self.uid, [wiz_id], {
'active_ids': [inv_id],
'from_model': 'giscedata.facturacio.importacio.linia'
})
new_comment = inv_o.read(self.cursor, self.uid, inv_id,
['user_observations'])['user_observations']
self.assertEqual(new_comment, '')
class EnviamentTests(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()
@unittest.skip('Pending refactor to remove empowering_profile_id from polissa')
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_not_emp_allow_recieve_mail_infoenergia(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'data_baixa': False, 'emp_allow_recieve_mail_infoenergia': False}
)
enviament.send_single_report()
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'cancellat'
)
mocked_send_mail.assert_not_called()
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_without_attachment(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'data_baixa': False}
)
enviament.send_single_report()
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'error'
)
mocked_send_mail.assert_not_called()
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_polissa_data_baixa(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'data_baixa': '2020-01-01'}
)
enviament.send_single_report()
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'baixa'
)
mocked_send_mail.assert_not_called()
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_polissa_inactiva(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'active': False}
)
enviament.send_single_report()
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'baixa'
)
mocked_send_mail.assert_not_called()
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_enviat(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
enviament.write({'estat':'enviat'})
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'data_baixa': False}
)
enviament.send_single_report()
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'enviat'
)
mocked_send_mail.assert_not_called()
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_allow_reenviar(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
enviament.write({'estat':'enviat'})
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'data_baixa': False}
)
enviament.send_single_report(context={'allow_reenviar':True})
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'enviat'
)
mocked_send_mail.assert_called_with(
context={'src_model': 'som.infoenergia.enviament',
'src_rec_ids': [enviament_id],
'allow_reenviar': True, 'template_id': enviament.lot_enviament.email_template.id,
'active_id': enviament_id
})
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_ok(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'data_baixa': False}
)
enviament.send_single_report()
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'obert'
)
mocked_send_mail.assert_called_with(
context={'src_model': 'som.infoenergia.enviament',
'src_rec_ids': [enviament_id],
'template_id': enviament.lot_enviament.email_template.id,
'active_id': enviament_id
})
@mock.patch("poweremail.poweremail_send_wizard.poweremail_send_wizard.send_mail")
def test_send_single_report_email_subject_context(self, mocked_send_mail):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
enviament = env_obj.browse(cursor, uid, enviament_id)
pol_id = enviament.polissa_id.id
pol_obj.write(cursor, uid, pol_id,
{'data_baixa': False}
)
ctx = {'email_subject':'Test subject', 'email_to':'*****@*****.**'}
enviament.send_single_report(context=ctx)
self.assertEqual(
env_obj.read(cursor, uid, enviament_id, ['estat'])['estat'], 'obert'
)
mocked_send_mail.assert_called_with(
context={'src_model': 'som.infoenergia.enviament',
'src_rec_ids': [enviament_id],
'template_id': enviament.lot_enviament.email_template.id,
'email_to': '*****@*****.**', 'email_subject': 'Test subject',
'active_id': enviament_id
})
def test_add_info_line__single_env_infoenergia(self):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1]
enviament = env_obj.browse(self.cursor, self.uid, enviament_id)
info_pre = enviament.info
enviament.add_info_line(u'Test add info line')
info_post = env_obj.read(self.cursor, self.uid, enviament_id, ['info'])['info']
self.assertTrue(u'Test add info line\n{}'.format(info_pre) in info_post)
def test_add_info_line__two_env_infoenergia(self):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
enviaments = []
enviaments.append(imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'enviament_obert_amb_attach'
)[1])
enviaments.append(imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'enviament_obert'
)[1])
info_pre_0 = env_obj.read(self.cursor, self.uid, enviaments[0], ['info'])['info']
info_pre_1 = env_obj.read(self.cursor, self.uid, enviaments[1], ['info'])['info']
env_obj.add_info_line(self.cursor, self.uid, enviaments, u'Test add info line')
info_post_0 = env_obj.read(self.cursor, self.uid, enviaments[0], ['info'])['info']
info_post_1 = env_obj.read(self.cursor, self.uid, enviaments[1], ['info'])['info']
self.assertTrue(u'Test add info line\n{}'.format(info_pre_0) in info_post_0)
self.assertTrue(u'Test add info line\n{}'.format(info_pre_1) in info_post_1)
def test_add_info_line__single_env_massiu(self):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.enviament.massiu')
enviament_id = imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'enviament_obert_tipus_altre'
)[1]
enviament = env_obj.browse(self.cursor, self.uid, enviament_id)
info_pre = enviament.info
enviament.add_info_line(u'Test add info line')
info_post = env_obj.read(self.cursor, self.uid, enviament_id, ['info'])['info']
self.assertTrue(u'Test add info line\n{}'.format(info_pre) in info_post)
def test_add_info_line__two_env_massiu(self):
imd_obj = self.openerp.pool.get('ir.model.data')
env_obj = self.openerp.pool.get('som.enviament.massiu')
enviaments = []
enviaments.append(imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'enviament_obert_tipus_altre'
)[1])
enviaments.append(imd_obj.get_object_reference(
self.cursor, self.uid, 'som_infoenergia', 'enviament_enviat_tipus_altre'
)[1])
info_pre_0 = env_obj.read(self.cursor, self.uid, enviaments[0], ['info'])['info']
info_pre_1 = env_obj.read(self.cursor, self.uid, enviaments[1], ['info'])['info']
env_obj.add_info_line(self.cursor, self.uid, enviaments, u'Test add info line')
info_post_0 = env_obj.read(self.cursor, self.uid, enviaments[0], ['info'])['info']
info_post_1 = env_obj.read(self.cursor, self.uid, enviaments[1], ['info'])['info']
self.assertTrue(u'Test add info line\n{}'.format(info_pre_0) in info_post_0)
self.assertTrue(u'Test add info line\n{}'.format(info_pre_1) in info_post_1)
class WizardCreateTechnicalReportTests(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__get_data__InvoiceF1NG_invoice20TD(self):
imd_obj = self.openerp.pool.get('ir.model.data')
fact_obj = self.openerp.pool.get('giscedata.facturacio.factura')
wiz_obj = self.openerp.pool.get('wizard.create.technical.report')
cursor = self.cursor
uid = self.uid
polissa_id = imd_obj.get_object_reference(cursor, uid,
'giscedata_polissa',
'polissa_0001')[1]
invoice_id = imd_obj.get_object_reference(cursor, uid, 'som_informe',
'factura_0067')[1]
ctx = {
'active_id': polissa_id,
'active_ids': [polissa_id],
}
wiz_id = wiz_obj.create(cursor, uid, {}, context=ctx)
wiz = wiz_obj.browse(cursor, uid, wiz_id)
invoice = fact_obj.browse(cursor, uid, invoice_id)
extractor = wiz_obj.factory_metadata_extractor('InvoiceF1NG')
result = extractor.get_data(cursor, uid, wiz, invoice)
self.assertEqual(
result, {
'invoice_type': u'N',
'date_from': '15-08-2021',
'amount_base': 10.0,
'invoice_date': '01-10-2021',
'invoiced_days': 32,
'date_to': '15-09-2021',
'date': '2021-10-01',
'invoice_number': u'12345678',
'numero_edm': u'004007',
'type': 'InvoiceF1NG',
'invoiced_energy': 1.0,
'amount_total': 10.0
})
def test__get_data__InvoiceF1NG_invoice30TD(self):
imd_obj = self.openerp.pool.get('ir.model.data')
fact_obj = self.openerp.pool.get('giscedata.facturacio.factura')
wiz_obj = self.openerp.pool.get('wizard.create.technical.report')
cursor = self.cursor
uid = self.uid
polissa_id = imd_obj.get_object_reference(cursor, uid,
'giscedata_polissa',
'polissa_tarifa_019')[1]
invoice_id = imd_obj.get_object_reference(cursor, uid, 'som_informe',
'factura_0068_30TD')[1]
ctx = {
'active_id': polissa_id,
'active_ids': [polissa_id],
}
wiz_id = wiz_obj.create(cursor, uid, {}, context=ctx)
wiz = wiz_obj.browse(cursor, uid, wiz_id)
invoice = fact_obj.browse(cursor, uid, invoice_id)
extractor = wiz_obj.factory_metadata_extractor('InvoiceF1NG')
result = extractor.get_data(cursor, uid, wiz, invoice)
self.assertEqual(
result, {
'invoice_type': u'N',
'date_from': '15-08-2021',
'amount_base': 10.0,
'invoice_date': '16-09-2021',
'invoiced_days': 32,
'date_to': '15-09-2021',
'date': '2021-09-16',
'invoice_number': u'12345679',
'numero_edm': u'004008',
'type': 'InvoiceF1NG',
'invoiced_energy': 1.0,
'amount_total': 10.0
})
class LotEnviamentTests(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()
@mock.patch('os.unlink')
def _attach_csv(self, cursor, uid, lot_enviament_id, csv_path, mocked):
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
return lot_env_obj._attach_csv(cursor, uid, lot_enviament_id, csv_path)
def _read_csv(self, csv_path):
results = []
with open(csv_path, 'r') as csvfile:
reader = csv.DictReader(csvfile, delimiter=';')
for row in reader:
results.append(row)
return results
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_csv')
def test_create_enviaments_from_csv_file(self, mocked_create_enviaments_from_csv):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
script_dir = os.path.dirname(__file__) #<-- absolute dir the script is in
rel_path = 'T1_2020_minimal.csv'
abs_file_path = os.path.join(script_dir, rel_path)
lot_enviament.create_enviaments_from_csv_file(abs_file_path, {})
mocked_create_enviaments_from_csv.assert_called_with(cursor, uid, [lot_enviament_id],
[{'report': '0001.pdf','text': 'First;Text', 'contractid': '0001'}],{})
@mock.patch('som_infoenergia.som_infoenergia_lot.SomInfoenergiaLotEnviament.create_enviaments_from_csv')
def test_create_enviaments_from_csv_file(self, mocked_create_enviaments_from_csv):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
script_dir = os.path.dirname(__file__) #<-- absolute dir the script is in
rel_path = 'EiE_extra_info.csv'
abs_file_path = os.path.join(script_dir, rel_path)
lot_enviament.create_enviaments_from_csv_file(abs_file_path, {})
mocked_create_enviaments_from_csv.assert_called_with(cursor, uid, [lot_enviament_id],
[{' codi_oferta': ' OFERTA1', 'polissa': '0001', 'import_garantia': '1000',
'consum_anual': ' 1400', 'marge': ' 1'}],{})
def test_create_single_enviament_polissaNotFound(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
env_data = {'contractid':'wrong', 'cups': '1',
'potencia':'2', 'tarifa':'2.0A','informe':'M2',
'text':'Text', 'valid':'True', 'report':'wrong.pdf'}
pre_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat','=','error')]
)
lot_enviament.create_single_enviament(env_data, {})
post_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat', "=", 'error'), ('found_in_search', '=', False)]
)
self.assertTrue(len(pre_enviaments) < len(post_enviaments))
envs_info = env_obj.read(cursor, uid, post_enviaments, ['info','estat'])
for e_info in envs_info:
self.assertTrue('error' == e_info['estat'])
self.assertTrue(('No s\'ha trobat la pòlissa ') in e_info['info'])
def test_create_single_enviament_updateEnviament(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
pol_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0001'
)[1]
pol_name = pol_obj.read(cursor, uid, pol_id, ['name'])['name']
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
lot_enviament.create_single_enviament_from_object(pol_id, context={'tipus': 'infoenergia'})
csv_updated_data = {'contractid': pol_name, 'cups': '1',
'potencia':'2', 'tarifa':'2.0A','informe':'M2',
'text':'Updated Text', 'valid':'True', 'report':'0001.pdf'}
lot_enviament.create_single_enviament(csv_updated_data, context={'path_pdf': 'test_path', 'tipus':'infoenergia'})
updated_env = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id), ('found_in_search', '=', True),
('pdf_filename','=','test_path/0001.pdf')]
)
self.assertEqual(len(updated_env),1)
self.assertEqual(env_obj.read(cursor, uid, updated_env, ['body_text'])[0]['body_text'], 'Updated Text')
def test_create_single_enviament_from_object_updateFoundInSearch(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
pol_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0001'
)[1]
pol_name = pol_obj.read(cursor, uid, pol_id, ['name'])['name']
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
csv_updated_data = {
'contractid': pol_name, 'cups': '1',
'potencia':'2', 'tarifa':'2.0A','informe':'M2',
'text':'Text', 'valid':'True', 'report':'0001.pdf'
}
lot_enviament.create_single_enviament(csv_updated_data, context={'path_pdf': 'test_path', 'tipus':'infoenergia'})
env_pre = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id), ('found_in_search', '=', False),
('pdf_filename','=','test_path/0001.pdf')]
)
self.assertEqual(len(env_pre), 1)
lot_enviament.create_single_enviament_from_object(pol_id, context={'tipus': 'infoenergia'})
updated_env = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id), ('found_in_search', '=', True),
('pdf_filename','=','test_path/0001.pdf')]
)
self.assertEqual(len(updated_env),1)
def test_create_single_enviament_polissaInactive(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
pol_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0001'
)[1]
pol_obj.write(cursor, uid, pol_id, {'name':'inactive','active':False})
pol_name = pol_obj.read(cursor, uid, pol_id, ['name'])['name']
csv_data = {'contractid':pol_name, 'cups': '1',
'potencia':'2', 'tarifa':'2.0A','informe':'M2',
'text':'Text', 'valid':'True', 'report':'{}.pdf'.format(pol_name)}
lot_enviament.create_single_enviament(csv_data, {})
post_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat', "=", 'baixa'), ('polissa_id','=', pol_id), ('found_in_search', '=', False),
('info','ilike','La pòlissa {} està donada de baixa'.format(pol_name))
])
self.assertEqual(len(post_enviaments), 1)
def test_create_single_enviament_from_object(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.infoenergia.enviament')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0001'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
pol_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0005'
)[1]
enviaments_in_lot = env_obj.search(cursor, uid, [('lot_enviament','=',lot_enviament_id),('polissa_id','=',pol_id)])
self.assertEqual(len(enviaments_in_lot), 0)
pol_name = pol_obj.read(cursor, uid, pol_id, ['name'])['name']
lot_enviament.create_single_enviament_from_object(pol_id, context={'tipus': 'infoenergia'})
post_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat', "=", 'preesborrany'), ('polissa_id','=', pol_id), ('found_in_search', '=', True),
('info','ilike','Enviament creat des de polissa_id')
])
self.assertEqual(len(post_enviaments), 1)
def test_create_single_enviament_from_object_lot_tipus_altres_from_pol(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
pol_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0005'
)[1]
enviaments_in_lot = env_obj.search(cursor, uid, [('lot_enviament','=',lot_enviament_id),('polissa_id','=',pol_id)])
self.assertEqual(len(enviaments_in_lot), 0)
pol_name = pol_obj.read(cursor, uid, pol_id, ['name'])['name']
lot_enviament.create_single_enviament_from_object(pol_id, context={'tipus': 'altres', 'from_model': 'polissa_id'})
post_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat', "=", 'obert'), ('polissa_id','=', pol_id),
('info','ilike','Enviament creat des de polissa_id')
])
self.assertEqual(len(post_enviaments), 1)
def test_create_single_enviament_from_object_lot_tipus_altres_from_partner(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
partner_id = imd_obj.get_object_reference(
cursor, uid, 'base', 'res_partner_5'
)[1]
enviaments_in_lot = env_obj.search(cursor, uid, [('lot_enviament','=',lot_enviament_id),('partner_id','=', partner_id)])
self.assertEqual(len(enviaments_in_lot), 0)
lot_enviament.create_single_enviament_from_object(partner_id, context={'tipus': 'altres', 'from_model': 'partner_id'})
post_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat', "=", 'obert'), ('partner_id','=', partner_id),
('info','ilike','Enviament creat des de partner_id')
])
self.assertEqual(len(post_enviaments), 1)
def test_create_single_enviament_from_object_lot_tipus_altres_from_partner_already_exist(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
partner_id = imd_obj.get_object_reference(
cursor, uid, 'base', 'res_partner_agrolait'
)[1]
enviaments_in_lot = env_obj.search(cursor, uid, [('lot_enviament','=',lot_enviament_id),('partner_id','=', partner_id)])
self.assertEqual(len(enviaments_in_lot), 1)
lot_enviament.create_single_enviament_from_object(partner_id, context={'tipus': 'altres', 'from_model': 'partner_id'})
post_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat', "=", 'enviat'), ('partner_id','=', partner_id),
])
self.assertEqual(len(post_enviaments), 1)
def test_create_single_enviament_from_object_extra_info(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
env_obj = self.openerp.pool.get('som.enviament.massiu')
pol_obj = self.openerp.pool.get('giscedata.polissa')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
pol_id = imd_obj.get_object_reference(
cursor, uid, 'giscedata_polissa', 'polissa_0005'
)[1]
enviaments_in_lot = env_obj.search(cursor, uid, [('lot_enviament','=',lot_enviament_id),('polissa_id','=',pol_id)])
self.assertEqual(len(enviaments_in_lot), 0)
lot_enviament.create_single_enviament_from_object(pol_id, context={'tipus': 'altres',
'from_model': 'polissa_id', 'extra_text': {'k': '234', 'extra_info': 'Info 1'}})
post_enviaments = env_obj.search(cursor, uid,
[("lot_enviament", "=", lot_enviament_id),
('estat', "=", 'obert'), ('polissa_id','=', pol_id),
])
self.assertEqual(len(post_enviaments), 1)
env_data = env_obj.read(cursor, uid, post_enviaments[0])
self.assertEqual(env_data['extra_text'], "{'k': '234', 'extra_info': 'Info 1'}")
@mock.patch('som_infoenergia.som_enviament_massiu.SomEnviamentMassiu.add_info_line')
def test_cancel_enviaments_from_polissa_names_altres(self, mock_add_info):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0002'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
cancellats_pre = lot_enviament.total_cancelats
lot_enviament.cancel_enviaments_from_polissa_names(['0001C','0002'], {'reason': 'Test cancel from polissa list'})
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
cancellats_post = lot_enviament.total_cancelats
self.assertEqual(cancellats_post, cancellats_pre + 2)
mock_add_info.assert_called_with(self.cursor, self.uid, mock.ANY, 'Enviament cancel·lat per Test cancel from polissa list')
@mock.patch('som_infoenergia.som_infoenergia_enviament.SomInfoenergiaEnviament.add_info_line')
def test_cancel_enviaments_from_polissa_names_infoenergia(self, mock_add_info):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0003'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
cancellats_pre = lot_enviament.total_cancelats
lot_enviament.cancel_enviaments_from_polissa_names(['0001C','0002'], {'reason': 'Test cancel from polissa list'})
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
cancellats_post = lot_enviament.total_cancelats
self.assertEqual(cancellats_post, cancellats_pre + 3)
mock_add_info.assert_called_with(self.cursor, self.uid, mock.ANY, 'Enviament cancel·lat per Test cancel from polissa list')
def test_ff_totals_ff_progress_altres(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0004'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
self.assertEqual(lot_enviament.total_enviaments, 4)
self.assertEqual(lot_enviament.total_env_csv, 0)
self.assertEqual(lot_enviament.total_env_csv_in_search, 0)
self.assertEqual(lot_enviament.total_enviats, 1)
self.assertEqual(lot_enviament.total_enviats_in_search, 0)
self.assertEqual(lot_enviament.total_encuats, 1)
self.assertEqual(lot_enviament.total_encuats_in_search, 0)
self.assertEqual(lot_enviament.total_oberts, 1)
self.assertEqual(lot_enviament.total_oberts_in_search, 0)
self.assertEqual(lot_enviament.total_esborrany, 0)
self.assertEqual(lot_enviament.total_esborrany_in_search, 0)
self.assertEqual(lot_enviament.total_preesborrany, 0)
self.assertEqual(lot_enviament.total_cancelats, 1)
self.assertEqual(lot_enviament.total_cancelats_in_search, 0)
self.assertEqual(lot_enviament.total_baixa, 0)
self.assertEqual(lot_enviament.total_baixa_in_search, 0)
self.assertEqual(lot_enviament.total_errors, 0)
self.assertEqual(lot_enviament.total_errors_in_search, 0)
self.assertEqual(lot_enviament.env_csv_progress, 0)
self.assertEqual(lot_enviament.pdf_download_progress, 0)
self.assertEqual(lot_enviament.env_sending_progress, 25)
def test_ff_totals_ff_progress_infoenergia(self):
imd_obj = self.openerp.pool.get('ir.model.data')
lot_env_obj = self.openerp.pool.get('som.infoenergia.lot.enviament')
cursor = self.cursor
uid = self.uid
lot_enviament_id = imd_obj.get_object_reference(
cursor, uid, 'som_infoenergia', 'lot_enviament_0003'
)[1]
lot_enviament = lot_env_obj.browse(cursor, uid, lot_enviament_id)
self.assertEqual(lot_enviament.total_preesborrany, 0)
self.assertEqual(lot_enviament.total_esborrany, 1)
self.assertEqual(lot_enviament.total_esborrany_in_search, 0)
self.assertEqual(lot_enviament.total_oberts, 2)
self.assertEqual(lot_enviament.total_oberts_in_search, 1)
self.assertEqual(lot_enviament.total_enviats, 0)
self.assertEqual(lot_enviament.total_enviats_in_search, 0)
self.assertEqual(lot_enviament.total_cancelats, 0)
self.assertEqual(lot_enviament.total_cancelats_in_search, 0)
self.assertEqual(lot_enviament.total_baixa, 0)
self.assertEqual(lot_enviament.total_baixa_in_search, 0)
self.assertEqual(lot_enviament.total_errors, 0)
self.assertEqual(lot_enviament.total_errors_in_search, 0)
self.assertEqual(lot_enviament.total_encuats, 0)
self.assertEqual(lot_enviament.total_encuats_in_search, 0)
self.assertEqual(lot_enviament.total_enviaments, 3)
self.assertEqual(lot_enviament.total_enviaments_in_search, 1)
self.assertEqual(lot_enviament.total_env_csv, 2)
self.assertEqual(lot_enviament.total_env_csv_in_search, 1)
self.assertEqual(lot_enviament.env_csv_progress, 66.66666666666666)
self.assertEqual(lot_enviament.pdf_download_progress, 66.66666666666666)
self.assertEqual(lot_enviament.env_sending_progress, 0)
