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()
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