def test_post_when_user_doesnt_own_plan(self):
request = RequestFactory().post('/', self.data)
request.user = self.user
request = add_middleware_to_request(request)
response = plan_clase_update(
request, pk=self.another_plan.pk, slug=self.another_plan.slug)
assert response.status_code == 302, 'Should return a redirection'
assert response.url == reverse('plan_clase_list')
def test_post_when_user_doesnt_own_plan(self):
request = RequestFactory().post('/', self.data)
request.user = self.user
request = add_middleware_to_request(request)
response = PlanAnualDeleteView.as_view()(request,
pk=self.another_plan.pk)
assert response.status_code == 302, 'Should return a redirection'
assert response.url == reverse('plan_anual_list')
# It should still exist
self.plan_anual.refresh_from_db()
def test_post_when_user_doesnt_own_plan(self):
request = RequestFactory().post('/', self.data)
request.user = self.user
request = add_middleware_to_request(request)
response = PlanAnualDuplicateView.as_view()(request,
pk=self.another_plan.pk)
assert response.status_code == 302, 'Should return a redirection'
assert response.url == reverse('plan_anual_list')
copias = PlanAnual.objects.filter(
name='{} (copia)'.format(self.another_plan.name))
assert len(copias) == 0, 'Should be no copies'
def test_empty_data(self):
"""Tests the view when sending empty data"""
request = RequestFactory().post('/', data={})
request.user = self.user
request = add_middleware_to_request(request)
response = PlanDestrezasCreateView.as_view()(request)
assert response.status_code == 200, 'Should return a success response'
assert 'Por favor corrija los campos resaltados en rojo.' \
in response.rendered_content, 'Should have an error message'
assert 'alert-danger' in response.rendered_content, \
'Should return an error message'
def test_invalid_data(self):
"""Tests the view when sending invalid data"""
self.data['name'] = ''
request = RequestFactory().post('/', data=self.data)
request.user = self.user
request = add_middleware_to_request(request)
response = PlanAnualCreateView.as_view()(request)
assert response.status_code == 200, 'Should get a success response'
assert 'Por favor corrija los campos resaltados en rojo.' \
in str(response.content), 'Should have an error message'
def test_invalid_data(self):
"""Tests the view when sending invalid data"""
self.data['name'] = ''
request = RequestFactory().post('/', data=self.data)
request.user = self.user
request = add_middleware_to_request(request)
response = PlanDestrezasUpdateView.as_view()(
request, pk=self.plan_destrezas.pk, slug=self.plan_destrezas.slug)
assert response.status_code == 200, 'Should return a success response'
assert 'Por favor corrija los campos resaltados en rojo.' \
in str(response.content), 'Should have an error message'
assert 'alert-danger' in str(response.content), \
'Should return an error message'
def test_success_plan_duplication(self):
"""Tests a plan has been successfuly duplicated"""
self.plan_anual.objetivos_curso.set([self.objetivo_1, self.objetivo_2])
self.plan_anual.objetivos_generales_curso.set(
[self.general_1, self.general_2])
self.plan_anual.objetivos_generales.set(
[self.general_1, self.general_2])
desarrollo_unidad_1 = mixer.blend(DesarrolloUnidad,
plan_anual=self.plan_anual,
unidad=self.unidad_1)
desarrollo_unidad_1.destrezas.set([self.destreza_1, self.destreza_2])
desarrollo_unidad_2 = mixer.blend(DesarrolloUnidad,
plan_anual=self.plan_anual,
unidad=self.unidad_2)
desarrollo_unidad_2.destrezas.set([self.destreza_1, self.destreza_2])
self.client.login(
username='******',
password='******',
)
url = reverse('plan_anual_duplicate',
kwargs={'pk': self.plan_anual.pk})
response = self.client.post(url, {}, follow=True)
assert response.status_code == 200, 'Should return a success code'
# Test success message
messages = list(response.context.get('messages'))
assert len(messages) == 1, 'Should return one message'
assert messages[0].message == 'Plan Anual duplicado exitosamente.',\
'Should return a success message'
assert messages[0].tags == 'alert-success', \
'Should return a success message'
self.assertRedirects(response, reverse('plan_anual_list'))
# Test plan anual
plan_anual_new = PlanAnual.objects.last()
desarrollo_unidad_new = DesarrolloUnidad.objects.last()
assert self.plan_anual.pk != plan_anual_new.pk, \
'Should be another instance'
assert plan_anual_new.name == '{} (copia)'.format(
self.plan_anual.name), 'Should have a new name'
assert plan_anual_new.curso == self.plan_anual.curso, \
'Should have the same property values'
# Debe tener igual todos los campos many to many al original
assert plan_anual_new.objetivos_curso.first() == self.objetivo_1
assert plan_anual_new.objetivos_curso.last() == self.objetivo_2
assert plan_anual_new.objetivos_generales_curso.first() == \
self.general_1
assert plan_anual_new.objetivos_generales_curso.last() == \
self.general_2
assert plan_anual_new.objetivos_generales.first() == self.general_1
assert plan_anual_new.objetivos_generales.last() == self.general_2
assert self.plan_anual.updated_at != plan_anual_new.updated_at, \
'The updated_at field should not be copied'
# Tests elemento curricular
desarrollo_unidad_new = plan_anual_new.desarrollo_unidades.first()
assert desarrollo_unidad_new.pk != desarrollo_unidad_1.pk, \
'Should be another instance'
assert desarrollo_unidad_new.plan_anual == plan_anual_new
assert desarrollo_unidad_new.unidad == \
desarrollo_unidad_1.unidad
# Debe tener igual todos los campos many to many
# al desarrollo de unidad original
assert desarrollo_unidad_new.destrezas.first() == self.destreza_1
assert desarrollo_unidad_new.destrezas.last() == self.destreza_2
# Test second duplication
request = RequestFactory().post('/', {})
request.user = self.user
request = add_middleware_to_request(request)
PlanAnualDuplicateView.as_view()(request, pk=self.plan_anual.pk)
plan_anual_new = PlanAnual.objects.last()
assert plan_anual_new.name == '{} (copia 2)'.format(
self.plan_anual.name)
assert plan_anual_new.curso == self.plan_anual.curso
# Test third duplication
PlanAnualDuplicateView.as_view()(request, pk=self.plan_anual.pk)
plan_anual_new = PlanAnual.objects.last()
assert plan_anual_new.name == '{} (copia 3)'.format(
self.plan_anual.name)
assert plan_anual_new.curso == self.plan_anual.curso
def test_success_plan_duplication(self):
"""Tests a plan has been successfuly duplicated"""
self.plan_clase.objetivos.set([self.objetivo_1, self.objetivo_2])
self.plan_clase.objetivos_generales.set(
[self.general_1, self.general_2])
self.plan_clase.cursos.set([self.curso_1, self.curso_2])
elemento_curricular_1 = mixer.blend(ElementoCurricular,
plan_clase=self.plan_clase,
destreza=self.destreza_1)
proceso_didactico_1 = mixer.blend(
ProcesoDidactico,
elemento_curricular=elemento_curricular_1
)
self.client.login(username='******',
password='******',)
url = reverse('plan_clase_duplicate',
kwargs={'pk': self.plan_clase.pk})
response = self.client.post(url, {}, follow=True)
assert response.status_code == 200, 'Should return a success code'
# Test success message
messages = list(response.context.get('messages'))
assert len(messages) == 1, 'Should return one message'
assert messages[0].message == 'Plan de clase duplicado exitosamente.',\
'Should return a success message'
assert messages[0].tags == 'alert-success', \
'Should return a success message'
self.assertRedirects(response, reverse('plan_clase_list'))
# Test plan de clase
plan_clase_new = PlanClase.objects.last()
elemento_curricular_new = ElementoCurricular.objects.last()
proceso_didactico_new = ProcesoDidactico.objects.last()
assert self.plan_clase.pk != plan_clase_new.pk, \
'Should be another instance'
assert plan_clase_new.name == '{} (copia)'.format(
self.plan_clase.name), 'Should have a new name'
assert plan_clase_new.tema == self.plan_clase.tema, \
'Should have the same property values'
# Debe tener igual todos los campos many to many al original
assert plan_clase_new.objetivos.first() == self.objetivo_1
assert plan_clase_new.objetivos.last() == self.objetivo_2
assert plan_clase_new.objetivos_generales.first() == self.general_1
assert plan_clase_new.objetivos_generales.last() == self.general_2
assert plan_clase_new.cursos.first() == self.curso_1
assert plan_clase_new.cursos.last() == self.curso_2
assert self.plan_clase.updated_at != plan_clase_new.updated_at, \
'The updated_at field should not be copied'
# Tests elemento curricular
elemento_curricular_new = plan_clase_new.elementos_curriculares.first()
assert elemento_curricular_new.pk != elemento_curricular_1.pk, \
'Should be another instance'
assert elemento_curricular_new.plan_clase == plan_clase_new
assert elemento_curricular_new.conocimientos_asociados == \
elemento_curricular_1.conocimientos_asociados
assert elemento_curricular_new.destreza == self.destreza_1
proceso_didactico_new = elemento_curricular_new.procesos_didacticos\
.first()
# Tests proceso didáctico
assert proceso_didactico_new.pk != proceso_didactico_1.pk, \
'Should be another instance'
assert proceso_didactico_new.elemento_curricular == \
elemento_curricular_new
assert proceso_didactico_new.name == proceso_didactico_1.name
# Test second duplication
request = RequestFactory().post('/', {})
request.user = self.user
request = add_middleware_to_request(request)
PlanClaseDuplicateView.as_view()(request,
pk=self.plan_clase.pk)
plan_clase_new = PlanClase.objects.last()
assert plan_clase_new.name == '{} (copia 2)'.format(
self.plan_clase.name)
assert plan_clase_new.tema == self.plan_clase.tema
# Test third duplication
PlanClaseDuplicateView.as_view()(request,
pk=self.plan_clase.pk)
plan_clase_new = PlanClase.objects.last()
assert plan_clase_new.name == '{} (copia 3)'.format(
self.plan_clase.name)
assert plan_clase_new.tema == self.plan_clase.tema