def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True,
is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
self.user_agente = self.crear_user_agente()
self.campana = CampanaFactory()
self.agente_profile = self.crear_agente_profile(self.user_agente)
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana, tipo=OpcionCalificacion.GESTION)
self.calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion)
self.grabacion1 = GrabacionFactory.create(
duracion=0,
agente=self.agente_profile,
callid=self.calificacion.callid,
campana=self.campana)
self.grabacion2 = GrabacionFactory(duracion=0,
agente=self.agente_profile,
campana=self.campana)
self.grabacion3 = GrabacionFactory(duracion=0,
agente=self.agente_profile,
campana=self.campana)
self.marca_campana1 = GrabacionMarcaFactory(
callid=self.grabacion1.callid)
self.marca_campana2 = GrabacionMarcaFactory(
callid=self.grabacion2.callid)
self.client.login(username=self.usuario_admin_supervisor.username,
password=self.PWD)
def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True, is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
self.agente_profile = AgenteProfileFactory.create(user=self.usuario_admin_supervisor)
self.nombre_calificacion = NombreCalificacionFactory.create(nombre=self.CALIFICACION_NOMBRE)
self.nombre_calificacion_gestion = NombreCalificacionFactory.create(nombre=self.GESTION)
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA, type=Campana.TYPE_PREVIEW)
self.contacto_calificado_gestion = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
self.contacto_calificado_no_accion = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
self.contacto_no_atendido = ContactoFactory(bd_contacto=self.campana_activa.bd_contacto)
self.contacto_no_calificado = ContactoFactory(bd_contacto=self.campana_activa.bd_contacto)
self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
campana=self.campana_activa, nombre=self.nombre_calificacion_gestion.nombre,
tipo=OpcionCalificacion.GESTION)
self.opcion_calificacion_noaccion = OpcionCalificacionFactory.create(
campana=self.campana_activa, nombre=self.nombre_calificacion.nombre,
tipo=OpcionCalificacion.NO_ACCION)
self.telefono1 = self.contacto_calificado_gestion.telefono
self.telefono2 = self.contacto_calificado_no_accion.telefono
self.telefono3 = self.contacto_no_atendido.telefono
self.telefono4 = self.contacto_no_calificado.telefono
self.generador_log_llamadas = GeneradorDeLlamadaLogs()
self.generador_log_llamadas.generar_log(
self.campana_activa, False, 'COMPLETEAGENT', self.telefono1, agente=self.agente_profile,
contacto=self.contacto_calificado_gestion, duracion_llamada=self.DURACION_LLAMADA,
callid=1)
self.generador_log_llamadas.generar_log(
self.campana_activa, False, 'COMPLETEAGENT', self.telefono2, agente=self.agente_profile,
contacto=self.contacto_calificado_no_accion, duracion_llamada=self.DURACION_LLAMADA,
callid=2)
self.generador_log_llamadas.generar_log(
self.campana_activa, True, 'NOANSWER', self.telefono3, agente=self.agente_profile,
contacto=self.contacto_no_atendido, callid=3)
self.generador_log_llamadas.generar_log(
self.campana_activa, True, 'COMPLETEOUTNUM', self.telefono4, agente=self.agente_profile,
contacto=self.contacto_no_calificado, duracion_llamada=0, callid=4)
callid_gestion = LlamadaLog.objects.get(
contacto_id=self.contacto_calificado_gestion.pk, event='COMPLETEAGENT').callid
callid_no_accion = LlamadaLog.objects.get(
contacto_id=self.contacto_calificado_no_accion.pk, event='COMPLETEAGENT').callid
self.calif_gestion = CalificacionClienteFactory.create(
opcion_calificacion=self.opcion_calificacion_gestion, agente=self.agente_profile,
contacto=self.contacto_calificado_gestion, callid=callid_gestion)
self.calif_no_accion = CalificacionClienteFactory.create(
opcion_calificacion=self.opcion_calificacion_noaccion, agente=self.agente_profile,
contacto=self.contacto_calificado_no_accion, callid=callid_no_accion)
CalificacionCliente.history.all().update(history_change_reason='calificacion')
self.client.login(username=self.usuario_admin_supervisor.username, password=self.PWD)
def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True,
is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
super(DashboardAgenteTests, self).setUp()
self.agente_profile = self.crear_agente_profile()
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA, type=Campana.TYPE_PREVIEW)
self.generador = GeneradorDeLlamadaLogs()
def setUp(self):
self.usuario_agente = UserFactory(is_agente=True)
self.usuario_agente.set_password(self.PWD)
self.usuario_agente.save()
self.usuario_admin = UserFactory(is_staff=True)
self.usuario_admin.set_password(self.PWD)
self.usuario_admin.save()
self.client.login(username=self.usuario_agente.username, password=self.PWD)
def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True,
is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
self.client.login(username=self.usuario_admin_supervisor.username,
password=self.PWD)
hasta = now()
desde = datetime_hora_minima_dia(hasta)
reporte = ReporteDeLlamadas(desde, hasta, True,
self.usuario_admin_supervisor)
self.estadisticas = reporte.estadisticas
def setUp(self):
super(CalificacionTests, self).setUp()
self.usuario_agente = UserFactory(is_agente=True)
self.usuario_agente.set_password(self.PWD)
self.usuario_agente.save()
self.campana = CampanaFactory.create()
self.nombre_opcion_gestion = NombreCalificacionFactory.create()
self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
nombre=settings.CALIFICACION_REAGENDA)
self.formulario = FormularioFactory()
self.campo_formulario = FieldFormularioFactory(
formulario=self.formulario)
self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=self.nombre_opcion_gestion.nombre,
tipo=OpcionCalificacion.GESTION,
formulario=self.formulario)
self.opcion_calificacion_agenda = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=self.nombre_calificacion_agenda.nombre,
tipo=OpcionCalificacion.AGENDA)
self.opcion_calificacion_camp_manual = OpcionCalificacionFactory.create(
campana=self.campana, nombre=self.nombre_opcion_gestion.nombre)
self.opcion_calificacion_no_accion = OpcionCalificacionFactory.create(
campana=self.campana, tipo=OpcionCalificacion.NO_ACCION)
self.contacto = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto)
self.queue = QueueFactory.create(campana=self.campana)
self.agente_profile = AgenteProfileFactory.create(
user=self.usuario_agente)
self.calificacion_cliente = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_camp_manual,
agente=self.agente_profile,
contacto=self.contacto)
QueueMemberFactory.create(member=self.agente_profile,
queue_name=self.queue)
self.client.login(username=self.usuario_agente.username,
password=self.PWD)
def crear_agentes(self):
self.agentes = []
for i in range(1, 5):
username = '******' % i
usrs = User.objects.filter(username=username)
if usrs.count() == 1:
agente = usrs[0].agenteprofile
else:
usr = UserFactory(username=username, is_agente=True)
agente = AgenteProfileFactory(user=usr)
self.agentes.append(agente)
def setUp(self):
super(GeneradorDeLlamadaLogsTests, self).setUp()
self.manual = CampanaFactory.create(type=Campana.TYPE_MANUAL)
self.usr_agente1 = UserFactory.create(username='******',
is_agente=True)
self.agente1 = AgenteProfileFactory.create(user=self.usr_agente1)
self.dialer = CampanaFactory.create(type=Campana.TYPE_DIALER)
self.contacto_d = ContactoFactory(bd_contacto=self.dialer.bd_contacto)
self.entrante = CampanaFactory.create(type=Campana.TYPE_ENTRANTE)
self.preview = CampanaFactory.create(type=Campana.TYPE_PREVIEW)
self.contacto_p = ContactoFactory(bd_contacto=self.preview.bd_contacto)
class RegistroTest(OMLBaseTest):
PWD = u'admin123'
def setUp(self):
self.usuario_agente = UserFactory(is_agente=True)
self.usuario_agente.set_password(self.PWD)
self.usuario_agente.save()
self.usuario_admin = UserFactory(is_staff=True)
self.usuario_admin.set_password(self.PWD)
self.usuario_admin.save()
self.client.login(username=self.usuario_agente.username, password=self.PWD)
def test_usuario_no_administrador_no_puede_registrar_instancia(self):
url = reverse('registrar_usuario')
post_data = {
'nombre': 'test-nombre',
'email': '*****@*****.**',
'telefono': '+54 9 333 7777',
}
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response, '403.html')
@patch('requests.post')
def test_usuario_no_administrador_puede_acceder_al_registro_de_su_instancia(self, post):
self.client.logout()
self.client.login(username=self.usuario_admin.username, password=self.PWD)
url = reverse('registrar_usuario')
response = requests.models.Response()
response.status_code = 200
response._content = json.dumps({"status": "OK", "msg": "Credentials created",
"user_name": config.CLIENT_NAME,
"user_key": config.CLIENT_KEY,
"user_email": config.CLIENT_EMAIL,
"user_phone": config.CLIENT_PHONE})
post.return_value = response
post_data = {
'nombre': 'test-nombre',
'email': '*****@*****.**',
'telefono': '+54 9 333 7777',
}
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response, 'registro.html')
class DashboardAgenteTests(OMLBaseTest):
PWD = u'admin123'
def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True,
is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
super(DashboardAgenteTests, self).setUp()
self.agente_profile = self.crear_agente_profile()
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA, type=Campana.TYPE_PREVIEW)
self.generador = GeneradorDeLlamadaLogs()
def test_se_muestran_estadisticas_del_dia_actual(self):
ayer = now() - timedelta(days=1)
self.generador.generar_log(self.campana_activa,
False,
'COMPLETEAGENT',
'35100001111',
agente=self.agente_profile,
contacto=None,
bridge_wait_time=-1,
duracion_llamada=10,
archivo_grabacion='',
time=ayer)
self.generador.generar_log(self.campana_activa,
False,
'COMPLETEOUTNUM',
'35100001112',
agente=self.agente_profile,
contacto=None,
bridge_wait_time=-1,
duracion_llamada=10,
archivo_grabacion='',
time=None)
reporte = ReporteEstadisticasDiariaAgente()
logs_agente_reporte = reporte.estadisticas[
self.agente_profile.pk]['logs']
self.assertEqual(len(logs_agente_reporte), 1)
def test_se_muestran_las_ultimas_10_llamadas(self):
numero_llamada_excluida = '3510000111'
ahora = now()
self.generador.generar_log(self.campana_activa,
False,
'COMPLETEAGENT',
numero_llamada_excluida,
agente=self.agente_profile,
contacto=None,
bridge_wait_time=-1,
duracion_llamada=10,
archivo_grabacion='',
time=ahora)
for i in range(1, 11):
time_llamada = ahora + timedelta(minutes=i)
self.generador.generar_log(self.campana_activa,
False,
'COMPLETEAGENT',
'35100213121',
agente=self.agente_profile,
contacto=None,
bridge_wait_time=-1,
duracion_llamada=10,
archivo_grabacion='',
time=time_llamada)
reporte = ReporteEstadisticasDiariaAgente()
reporte_agente = reporte.estadisticas[self.agente_profile.pk]
llamada_excluida_encontrada = False
for log in reporte_agente['logs']:
if log['phone'] == numero_llamada_excluida:
llamada_excluida_encontrada = True
self.assertFalse(llamada_excluida_encontrada)
def test_se_muestra_el_tiempo_de_sesion_correctamente(self):
horas_sesion = 1
tiempo_inicial = now()
ActividadAgenteLogFactory.create(event='UNPAUSEALL',
agente_id=self.agente_profile.id,
time=tiempo_inicial)
tiempo_removemember_1 = tiempo_inicial + timedelta(microseconds=20000)
ActividadAgenteLogFactory.create(event='REMOVEMEMBER',
agente_id=self.agente_profile.id,
time=tiempo_removemember_1)
tiempo_addmember = tiempo_removemember_1 + timedelta(microseconds=3000)
ActividadAgenteLogFactory.create(time=tiempo_addmember,
event='ADDMEMBER',
agente_id=self.agente_profile.id,
pausa_id='')
tiempo_removemember_2 = tiempo_addmember + timedelta(
hours=horas_sesion)
ActividadAgenteLogFactory.create(time=tiempo_removemember_2,
event='REMOVEMEMBER',
agente_id=self.agente_profile.id,
pausa_id='')
reporte = ReporteEstadisticasDiariaAgente()
reporte_agente = reporte.estadisticas[self.agente_profile.pk]
self.assertEqual(reporte_agente['tiempos'].sesion,
timedelta(hours=horas_sesion))
def test_se_muestran_los_tiempos_de_pausa_correctamente(self):
horas_sesion = 1
tiempo_inicial = now()
pausa1 = PausaFactory(tipo=Pausa.TIPO_PRODUCTIVA)
pausa2 = PausaFactory(tipo=Pausa.TIPO_RECREATIVA)
ActividadAgenteLogFactory.create(event='UNPAUSEALL',
agente_id=self.agente_profile.id,
time=tiempo_inicial)
tiempo_removemember_1 = tiempo_inicial + timedelta(microseconds=20000)
ActividadAgenteLogFactory.create(event='REMOVEMEMBER',
agente_id=self.agente_profile.id,
time=tiempo_removemember_1)
tiempo_addmember = tiempo_removemember_1 + timedelta(microseconds=3000)
ActividadAgenteLogFactory.create(time=tiempo_addmember,
event='ADDMEMBER',
agente_id=self.agente_profile.id,
pausa_id='')
tiempo_inicio_pausa_1 = tiempo_addmember + timedelta(minutes=2)
ActividadAgenteLogFactory.create(time=tiempo_inicio_pausa_1,
event='PAUSEALL',
agente_id=self.agente_profile.id,
pausa_id=pausa1.id)
tiempo_final_pausa_1 = tiempo_inicio_pausa_1 + timedelta(minutes=2)
ActividadAgenteLogFactory.create(time=tiempo_final_pausa_1,
event='UNPAUSEALL',
agente_id=self.agente_profile.id,
pausa_id=pausa1.id)
tiempo_inicio_pausa_2 = tiempo_final_pausa_1 + timedelta(minutes=2)
ActividadAgenteLogFactory.create(time=tiempo_inicio_pausa_2,
event='PAUSEALL',
agente_id=self.agente_profile.id,
pausa_id=pausa2.id)
tiempo_final_pausa_2 = tiempo_inicio_pausa_2 + timedelta(minutes=2)
ActividadAgenteLogFactory.create(time=tiempo_final_pausa_2,
event='UNPAUSEALL',
agente_id=self.agente_profile.id,
pausa_id=pausa2.id)
tiempo_removemember_2 = tiempo_final_pausa_2 + timedelta(
hours=horas_sesion)
ActividadAgenteLogFactory.create(time=tiempo_removemember_2,
event='REMOVEMEMBER',
agente_id=self.agente_profile.id,
pausa_id='')
reporte = ReporteEstadisticasDiariaAgente()
reporte_agente = reporte.estadisticas[self.agente_profile.pk]
self.assertEqual(reporte_agente['tiempos'].pausa, timedelta(minutes=4))
self.assertEqual(reporte_agente['tiempos'].pausa_recreativa,
timedelta(minutes=2))
class AccesoReportesTests(TestCase):
PWD = u'admin123'
def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True,
is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
self.client.login(username=self.usuario_admin_supervisor.username,
password=self.PWD)
hasta = now()
desde = datetime_hora_minima_dia(hasta)
reporte = ReporteDeLlamadas(desde, hasta, True,
self.usuario_admin_supervisor)
self.estadisticas = reporte.estadisticas
def test_usuario_logueado_accede_a_pagina_ppal_reportes_llamadas(self):
url = reverse('reporte_llamadas')
response = self.client.get(url, follow=True)
self.assertTemplateUsed(response, 'reporte_llamadas.html')
self.assertIn('estadisticas', response.context)
self.assertIn('estadisticas_por_fecha', response.context)
self.assertIn('graficos', response.context)
self.assertIn('estadisticas_json', response.context)
self.assertIn('desde', response.context)
self.assertIn('hasta', response.context)
def test_usuario_no_logueado_no_accede_a_pagina_ppal_reportes_llamadas(
self):
url = reverse('reporte_llamadas')
self.client.logout()
response = self.client.get(url, follow=True)
self.assertTemplateUsed(response, u'registration/login.html')
def test_usuario_logueado_accede_a_realizar_reporte_llamadas_por_tipo_csv(
self):
url = reverse('csv_reporte_llamadas')
data = {
'tipo_reporte': 'llamadas_por_tipo',
'estadisticas': json.dumps(self.estadisticas)
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(
str(response.serialize()).find('llamadas_por_tipo.csv') > -1)
def test_usuario_logueado_con_mal_parametro_tira_400(self):
url = reverse('csv_reporte_llamadas')
data = {
'tipo_reporte': 'reporte_inexistente',
'estadisticas': json.dumps(self.estadisticas)
}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 400)
self.assertTemplateUsed(response, u'400.html')
def test_usuario_no_logueado_no_accede_a_realizar_reporte_total_llamadas_csv(
self):
url = reverse('csv_reporte_llamadas')
data = {
'tipo_reporte': 'llamadas_por_tipo',
'estadisticas': json.dumps(self.estadisticas)
}
self.client.logout()
response = self.client.post(url, data=data, follow=True)
self.assertFalse(
str(response.serialize()).find('llamadas_por_tipo.csv') > -1)
def test_usuario_logueado_accede_a_zip_reportes_llamadas(self):
url = reverse('zip_reportes_llamadas')
data = {'estadisticas': json.dumps(self.estadisticas)}
response = self.client.post(url, data=data, follow=True)
self.assertTrue(
str(response.serialize()).find('llamadas_por_tipo.csv') > -1)
self.assertTrue(
str(response.serialize()).find('llamadas_por_campana.csv') > -1)
self.assertTrue(
str(response.serialize()).find('tipos_de_llamada_manual.csv') > -1)
self.assertTrue(
str(response.serialize()).find('tipos_de_llamada_dialer.csv') > -1)
self.assertTrue(
str(response.serialize()).find('tipos_de_llamada_entrante.csv') >
-1)
self.assertTrue(
str(response.serialize()).find('tipos_de_llamada_preview.csv') > -1
)
def test_usuario_no_logueado_no_accede_a_zip_reportes_llamadas(self):
url = reverse('zip_reportes_llamadas')
data = {'estadisticas': json.dumps(self.estadisticas)}
self.client.logout()
response = self.client.post(url, data=data, follow=True)
self.assertFalse(
str(response.serialize()).find('total_llamadas.csv') > -1)
def test_usuario_logueado_con_mal_parametro_tira_400_zip(self):
url = reverse('zip_reportes_llamadas')
data = {'estadisticas': self.estadisticas}
response = self.client.post(url, data=data, follow=True)
self.assertEqual(response.status_code, 400)
self.assertTemplateUsed(response, u'400.html')
class CalificacionTests(OMLBaseTest):
PWD = u'admin123'
def setUp(self):
super(CalificacionTests, self).setUp()
self.usuario_agente = UserFactory(is_agente=True)
self.usuario_agente.set_password(self.PWD)
self.usuario_agente.save()
self.campana = CampanaFactory.create()
self.nombre_opcion_gestion = NombreCalificacionFactory.create()
self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
nombre=settings.CALIFICACION_REAGENDA)
self.formulario = FormularioFactory()
self.campo_formulario = FieldFormularioFactory(
formulario=self.formulario)
self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=self.nombre_opcion_gestion.nombre,
tipo=OpcionCalificacion.GESTION,
formulario=self.formulario)
self.opcion_calificacion_agenda = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=self.nombre_calificacion_agenda.nombre,
tipo=OpcionCalificacion.AGENDA)
self.opcion_calificacion_camp_manual = OpcionCalificacionFactory.create(
campana=self.campana, nombre=self.nombre_opcion_gestion.nombre)
self.opcion_calificacion_no_accion = OpcionCalificacionFactory.create(
campana=self.campana, tipo=OpcionCalificacion.NO_ACCION)
self.contacto = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto)
self.queue = QueueFactory.create(campana=self.campana)
self.agente_profile = AgenteProfileFactory.create(
user=self.usuario_agente)
self.calificacion_cliente = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_camp_manual,
agente=self.agente_profile,
contacto=self.contacto)
QueueMemberFactory.create(member=self.agente_profile,
queue_name=self.queue)
self.client.login(username=self.usuario_agente.username,
password=self.PWD)
def _setUp_campana_dialer(self):
self.campana_dialer = CampanaFactory.create(type=Campana.TYPE_DIALER)
self.campana_dialer.opciones_calificacion.add(
self.opcion_calificacion_gestion)
self.campana_dialer.opciones_calificacion.add(
self.opcion_calificacion_agenda)
self.contacto_dialer = ContactoFactory.create()
self.campana_dialer.bd_contacto.contactos.add(self.contacto_dialer)
self.queue_dialer = QueueFactory.create(campana=self.campana_dialer)
QueueMemberFactory.create(member=self.agente_profile,
queue_name=self.queue_dialer)
def _obtener_post_data_calificacion_cliente(self,
campana=None,
contacto=None):
if campana is None:
campana = self.campana
if contacto is None:
contacto = self.contacto
post_data = {
'contacto_form-telefono': contacto.telefono,
'campana': campana.pk,
'contacto': contacto.pk,
'agente': self.agente_profile.pk,
'opcion_calificacion': '',
}
return post_data
def test_no_se_admite_tipo_calificacion_cliente_vacia_en_creacion_calificacion(
self):
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_calificacion_cliente()
response = self.client.post(url, post_data, follow=True)
calificacion_form = response.context_data.get('calificacion_form')
self.assertFalse(calificacion_form.is_valid())
def test_no_se_admite_tipo_calificacion_cliente_vacia_en_modificacion_calificacion(
self):
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_calificacion_cliente()
response = self.client.post(url, post_data, follow=True)
calificacion_form = response.context_data.get('calificacion_form')
self.assertFalse(calificacion_form.is_valid())
@patch('requests.post')
def test_calificacion_cliente_creacion_redirecciona_formulario_gestion(
self, post):
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_calificacion_cliente()
post_data['opcion_calificacion'] = self.opcion_calificacion_gestion.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response,
'formulario/respuesta_formulario_create.html')
self.assertTrue(self.campo_formulario.nombre_campo in
response.context_data['form'].fields)
@patch('requests.post')
def test_calificacion_cliente_creacion_redirecciona_a_otro_formulario_gestion(
self, post):
nuevo_formulario = FormularioFactory()
campo_formulario = FieldFormularioFactory(formulario=nuevo_formulario,
nombre_campo='otro_campo')
nombre_opcion = NombreCalificacionFactory.create(nombre='otra opcion')
opcion_calificacion = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=nombre_opcion,
tipo=OpcionCalificacion.GESTION,
formulario=nuevo_formulario)
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_calificacion_cliente()
post_data['opcion_calificacion'] = opcion_calificacion.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response,
'formulario/respuesta_formulario_create.html')
self.assertTrue(campo_formulario.nombre_campo in
response.context_data['form'].fields)
self.assertFalse(self.campo_formulario.nombre_campo in
response.context_data['form'].fields)
@patch('requests.post')
def test_calificacion_cliente_modificacion_redirecciona_formulario_gestion(
self, post):
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_calificacion_cliente()
post_data['opcion_calificacion'] = self.opcion_calificacion_gestion.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response,
'formulario/respuesta_formulario_create.html')
@patch('requests.post')
def test_calificacion_cliente_modificacion_gestion_por_no_accion(
self, post):
contacto_califica = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(contacto_califica)
calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_gestion,
agente=self.agente_profile,
contacto=contacto_califica)
RespuestaFormularioGestionFactory(calificacion=calificacion)
# Se modifica la calificacion por una de no accion
url_calificacion = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': contacto_califica.pk
})
post_data_calificacion = self._obtener_post_data_calificacion_cliente(
contacto=contacto_califica)
post_data_calificacion[
'opcion_calificacion'] = self.opcion_calificacion_no_accion.pk
self.client.post(url_calificacion, post_data_calificacion, follow=True)
self.assertIsNone(
CalificacionCliente.objects.get(
opcion_calificacion__campana=self.campana,
contacto_id=contacto_califica.id).get_venta())
def test_existe_calificacion_especial_agenda(self):
self.assertTrue(
NombreCalificacion.objects.filter(
nombre=settings.CALIFICACION_REAGENDA))
def _obtener_post_data_calificacion_manual(self):
post_data = {
'agente': self.agente_profile.pk,
'calificacion': '',
'observaciones': 'test',
'campana': self.campana.pk,
'agendado': False,
'telefono': self.contacto.pk
}
return post_data
@patch('requests.post')
def test_escoger_calificacion_agenda_redirecciona_formulario_agenda(
self, post):
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_calificacion_cliente()
post_data['opcion_calificacion'] = self.opcion_calificacion_agenda.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response,
'agenda_contacto/create_agenda_contacto.html')
@patch('requests.post')
def test_calificacion_cliente_marcada_agendado_cuando_se_salva_agenda(
self, post):
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.agendado = False
self.calificacion_cliente.save()
url = reverse('agenda_contacto_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_agenda()
self.assertFalse(self.calificacion_cliente.agendado)
self.client.post(url, post_data, follow=True)
self.calificacion_cliente.refresh_from_db()
self.assertTrue(self.calificacion_cliente.agendado)
def _obtener_post_data_agenda(self):
observaciones = 'test_schedule'
siguiente_dia = timezone.now() + timezone.timedelta(days=1)
fecha = str(siguiente_dia.date())
hora = str(siguiente_dia.time())
post_data = {
'contacto': self.contacto.pk,
'campana': self.campana.pk,
'agente': self.agente_profile.pk,
'fecha': fecha,
'telefono': self.contacto.telefono,
'hora': hora,
'tipo_agenda': AgendaContacto.TYPE_PERSONAL,
'observaciones': observaciones
}
return post_data
@patch('requests.post')
def test_no_se_programan_en_wombat_agendas_globales_calificaciones_campanas_no_dialer(
self, post):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.save()
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
url = reverse('agenda_contacto_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_agenda()
post_data['tipo_agenda'] = AgendaContacto.TYPE_GLOBAL
self.client.post(url, post_data, follow=True)
self.assertEqual(post.call_count, 0)
@patch('requests.post')
def test_se_programan_en_wombat_agendas_globales_calificaciones_campanas_dialer(
self, post):
self.campana.type = Campana.TYPE_DIALER
self.campana.save()
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
url = reverse('agenda_contacto_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_agenda()
post_data['tipo_agenda'] = AgendaContacto.TYPE_GLOBAL
self.client.post(url, post_data, follow=True)
self.assertEqual(post.call_count, 1)
@patch('requests.post')
def test_creacion_agenda_contacto_adiciona_campo_campana(self, post):
self.calificacion_cliente.opcion_calificacion_gestion = self.opcion_calificacion_agenda
url = reverse('agenda_contacto_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_agenda()
self.client.post(url, post_data, follow=True)
agenda_contacto = AgendaContacto.objects.first()
self.assertEqual(agenda_contacto.campana.pk, self.campana.pk)
def test_llamada_manual_telefono_no_contacto_crea_contacto(self):
# garantizamos un número distinto al existente en la campaña
contactos_ids = self.campana.bd_contacto.contactos.values_list(
'id', flat=True)
contactos_ids = list(contactos_ids)
telefono = str(self.contacto.telefono) + '11'
post_data = {
'opcion_calificacion': self.opcion_calificacion_gestion.pk,
'contacto_form-telefono': telefono,
'contacto_form-nombre': 'Nuevo Contacto'
}
url = reverse('calificar_por_telefono',
kwargs={
'pk_campana': self.campana.pk,
'telefono': telefono
})
response = self.client.post(url, post_data, follow=True)
self.assertEqual(response.status_code, 200)
nuevo_contacto = self.campana.bd_contacto.contactos.exclude(
id__in=contactos_ids)
self.assertEqual(nuevo_contacto.count(), 1)
nuevo_contacto = nuevo_contacto[0]
self.assertEqual(nuevo_contacto.telefono, telefono)
self.assertIn('Nuevo Contacto', nuevo_contacto.datos)
self.assertFalse(nuevo_contacto.es_originario)
def test_llamada_manual_telefono_no_contacto_muestra_formulario_calificacion_blanco(
self):
# garantizamos un número distinto al existente en la campaña
telefono = str(self.contacto.telefono) + '11'
url = reverse('calificar_por_telefono',
kwargs={
'pk_campana': self.campana.pk,
'telefono': telefono
})
response = self.client.get(url, follow=True)
contacto_form = response.context_data['contacto_form']
datos_contacto_form = set(contacto_form.initial.values())
self.assertEqual(datos_contacto_form, set([telefono]))
def test_llamada_manual_telefono_con_1_contacto_muestra_datos_contacto_formulario(
self):
contacto = self.contacto
telefono = contacto.telefono
url = reverse('calificar_por_telefono',
kwargs={
'pk_campana': self.campana.pk,
'telefono': telefono
})
response = self.client.get(url, follow=True)
contacto_form = response.context_data['contacto_form']
datos_contacto_form = set(contacto_form.initial.values())
datos_contacto_model = set(
json.loads(contacto.datos) + [str(telefono)])
datos_contacto_model.add(contacto.id_externo)
self.assertEqual(datos_contacto_form, datos_contacto_model)
def test_llamada_manual_telefono_con_n_contactos_redirecciona_vista_escoger_contacto(
self):
contacto = self.contacto
ContactoFactory(bd_contacto=self.campana.bd_contacto,
telefono=contacto.telefono)
telefono = contacto.telefono
url = reverse('calificar_por_telefono',
kwargs={
'pk_campana': self.campana.pk,
'telefono': telefono
})
response = self.client.get(url, follow=True)
self.assertTemplateUsed(response,
'agente/contactos_telefonos_repetidos.html')
def test_muestra_nombre_campana(self):
url = reverse('calificar_por_telefono',
kwargs={
'pk_campana': self.campana.pk,
'telefono': '351111111111'
})
response = self.client.get(url, follow=True)
self.assertContains(response, self.campana.nombre)
def test_oculta_nombre_campana(self):
self.campana.mostrar_nombre = False
self.campana.save()
url = reverse('calificar_por_telefono',
kwargs={
'pk_campana': self.campana.pk,
'telefono': '351111111111'
})
response = self.client.get(url, follow=True)
self.assertNotContains(response, self.campana.nombre)
def get_call_data(self):
call_data = {
"id_campana": self.campana.id,
"campana_type": self.campana.type,
"telefono": "3512349992",
"call_id": '123456789',
"call_type": "4",
"id_contacto": self.contacto.id,
"rec_filename": "",
"call_wait_duration": ""
}
return call_data
def test_muestra_link_sitio_externo(self):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.tipo_interaccion = Campana.SITIO_EXTERNO
sitio_externo = SitioExternoFactory()
self.campana.sitio_externo = sitio_externo
self.campana.save()
parametro1 = ParametrosCrmFactory(campana=self.campana)
call_data = self.get_call_data()
url = reverse('calificar_llamada',
kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
self.assertContains(response, sitio_externo.url)
self.assertContains(
response, '"%s": "%s"' % (parametro1.nombre, parametro1.valor))
def test_redirecciona_a_sitio_externo(self):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.tipo_interaccion = Campana.SITIO_EXTERNO
sitio_externo = SitioExternoFactory(disparador=SitioExterno.AUTOMATICO,
metodo=SitioExterno.GET,
objetivo=SitioExterno.EMBEBIDO)
self.campana.sitio_externo = sitio_externo
self.campana.save()
parametro1 = ParametrosCrmFactory(campana=self.campana)
call_data = self.get_call_data()
url = reverse('calificar_llamada',
kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url, follow=False)
self.assertEqual(response.status_code, 302)
param_1 = '%s=%s' % (parametro1.nombre, parametro1.valor)
equal_url = (response.url == '%s?%s' % (sitio_externo.url, param_1))
self.assertTrue(equal_url)
@patch('requests.get')
def test_hace_peticion_sitio_externo_en_servidor(self, request_get):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.tipo_interaccion = Campana.SITIO_EXTERNO
sitio_externo = SitioExternoFactory(disparador=SitioExterno.SERVER,
metodo=SitioExterno.GET,
objetivo=None,
formato=None)
self.campana.sitio_externo = sitio_externo
self.campana.save()
ParametrosCrmFactory(campana=self.campana)
call_data = self.get_call_data()
url = reverse('calificar_llamada',
kwargs={'call_data_json': json.dumps(call_data)})
self.client.get(url)
parametros = sitio_externo.get_parametros(self.agente_profile,
self.campana, self.contacto,
call_data)
request_get.assert_called_with(sitio_externo.url, params=parametros)
def test_se_muestra_historico_calificaciones_contacto_llamada_entrante(
self):
self.campana.type = Campana.TYPE_ENTRANTE
self.campana.save()
observacion_anterior = self.calificacion_cliente.observaciones
self.calificacion_cliente.observaciones = "NUEVA OBSERVACION"
self.calificacion_cliente.save()
call_data = self.get_call_data()
call_data["call_type"] = str(self.campana.type)
url = reverse('calificar_llamada',
kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
self.assertContains(response, observacion_anterior)
def test_no_se_muestra_historico_calificaciones_contacto_llamada_no_entrante(
self):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.save()
observacion_anterior = self.calificacion_cliente.observaciones
self.calificacion_cliente.observaciones = "NUEVA OBSERVACION"
self.calificacion_cliente.save()
call_data = self.get_call_data()
call_data["call_type"] = str(self.campana.type)
url = reverse('calificar_llamada',
kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
self.assertNotContains(response, observacion_anterior)
def test_llamada_entrante_con_numero_privado_inicializa_nuevo_contacto(
self):
self.campana.type = Campana.TYPE_ENTRANTE
self.campana.save()
call_id = "123456789.34"
telefono = "NUMERO PRIVADO"
call_data = self.get_call_data()
call_data["telefono"] = str(telefono)
call_data["call_id"] = call_id
call_data["call_type"] = str(self.campana.type)
url = reverse('calificar_llamada',
kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
contacto_form = response.context_data['contacto_form']
self.assertEqual(contacto_form.instance.pk, None)
def test_metodo_contactos_no_calificados_devuelve_valores_correctos(self):
contactos_no_calificados_count = self.campana.obtener_contactos_no_calificados(
).count()
self.assertEqual(contactos_no_calificados_count, 0)
def test_calificacion_cliente_cambio_a_no_agenda_elimina_agendas__globales_existentes(
self):
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
AgendaContactoFactory(agente=self.agente_profile,
contacto=self.contacto,
campana=self.campana,
tipo_agenda=AgendaContacto.TYPE_PERSONAL)
self.assertTrue(AgendaContacto.objects.exists())
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_no_accion
self.calificacion_cliente.save()
self.assertFalse(AgendaContacto.objects.exists())
def test_calificacion_cliente_cambio_a_no_agenda_no_elimina_agendas_personales_existentes(
self):
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
AgendaContactoFactory(agente=self.agente_profile,
contacto=self.contacto,
campana=self.campana,
tipo_agenda=AgendaContacto.TYPE_GLOBAL)
self.assertTrue(AgendaContacto.objects.exists())
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_no_accion
self.calificacion_cliente.save()
self.assertTrue(AgendaContacto.objects.exists())
def test_vista_calificar_contacto_muestra_botones_click2call(self):
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
response = self.client.get(url)
self.assertTemplateUsed(response,
'formulario/calificacion_create_update.html')
click2call = "makeClick2Call('%s', '%s', '%s', '%s', 'agendas')" % \
(self.campana.id, self.campana.type, self.contacto.id, self.contacto.telefono)
self.assertContains(response, click2call)
bd_metadata = self.contacto.bd_contacto.get_metadata()
campos_telefono = bd_metadata.nombres_de_columnas_de_telefonos
datos_contacto = self.contacto.obtener_datos()
for campo_telefono in campos_telefono:
telefono = datos_contacto[campo_telefono]
click2call = "makeClick2Call('%s', '%s', '%s', '%s', 'agendas')" % \
(self.campana.id, self.campana.type, self.contacto.id, telefono)
self.assertContains(response, click2call)
def test_no_se_admite_mas_de_una_calificacion_para_un_contacto_en_una_campana_creacion(
self):
opcion_calificacion = self.calificacion_cliente.opcion_calificacion
contacto = self.contacto
self.assertRaises(
ValidationError, lambda: CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion, contacto=contacto))
def test_no_se_admite_mas_de_una_calificacion_para_un_contacto_en_una_campana_modificacion(
self):
def modificar_calificacion():
calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_no_accion)
calificacion.contacto = self.contacto
calificacion.save()
self.assertRaises(ValidationError, modificar_calificacion)
