Mockito para tus pruebas unitarias

1. para tus pruebas
unitarias
ANTONIO ROBRES TURÓN

2. Quien soy?
 Test Architect en SCRM (Lidl Group)
 11 Años experiencia en Software Testing
 10 años experiencia en Automation Testing
 Python
 Java
 Javascript
 Ruby
 Retrogamer y amante de los comics

3. Agenda
 Introduction
 Unit Testing
 Test Doubles
 Mockito
 Using mock in high level components

7. Una test unitario es una forma de comprobar el correcto
funcionamiento de una unidad funcional de código de forma
aislada

8. Características Test Unitario
 Automático
 Predecible
 Enfocado
 Rápido
 Aislado
 Repetible

9. Estructura Test Unitario
 Arrange
 Parte donde se configura e inicializa el Test unitario
 Act
 Es la parte donde se ejecuta el código del Test unitario
 Assert
 Es la parte donde se valida el resultado del Test unitario

10. Buenas prácticas
 Independencia entre tests
 Nombre descriptivo de los tests
 Cada test solo prueba una cosa
 Implementar Test Doubles para las dependencias

11. Test Doubles

12. Tipos de Test Doubles

13. Mocking es el proceso por el cual el test decide la
implementación y comportamiento que tendrán las
dependencias de la clase que se va a probar.

14. Porque hacer mocks?
Elimina dependencias en el componente que estamos probando
Permiten testear métodos o funciones que no retornan ningún valor
permite poder probar errores
Reduce la complejidad de los tests (unitarios, de componente o de integración)
Posibilita desarrollar la clase sin esperar a que el resto de componentes estén acabados.

15. Dummies
Son dobles de test usados como
parámetros obligatorios de un
elemento con los que no se quiere
interactuar.
Suelen ser objetos vacíos ya que
no se van a utilizar directamente
en el test.

16. Fake
Son implementaciones de
componentes funcionales y
operativas pero con lo
mínimo necesario para
realizar los tests.
Los tests no tienen control
sobre estos.

17. Mock
Son dobles de tests que son
capaces de analizar la relación
entre el componente que
estamos probando y sus
interacciones.
Nos ayuda a saber el análisis
del comportamiento del
componente que estamos
probando.

18. Spy
Se utilizan también para
analizar la relación entre el
componente que estamos
probando y sus
interacciones pero sin
sustituir al objeto real.

19. Stub
 Es un componente que tiene
un comportamiento
predefinido y que se utiliza
para responder a las llamadas
del componente que estamos
probando.
 Este componente sustituye al
objeto real

21. Dummy example
class SuperPower():
name = None
def __init__(self, name):
self.name = name
def use(self):
print('Super Power Used')
class SuperHero:
first_name = None
second_name = None
def __init__(self, first_name, second_name, super_power):
self.first_name = first_name
self.second_name = second_name
self.super_power = super_power
def get_first_name(self):
return self.first_name
def get_second_name(self):
return self.second_name
def get_full_name(self):
return self.first_name + ' ' + self.second_name
def attack(self):
self.super_power.use()
import pytest
from unittest.mock import sentinel
from src.dummy import SuperHero
def test_super_hero():
hero = SuperHero(first_name='Doctor', second_name='Strange' ,
super_power=sentinel)
print(hero.get_full_name())

22. Lo que une el desarrollo que no lo
separen las pruebas

23. Problema
 Necesitamos un método que retorne a un candidato aleatorio:
 No puedes ser tu mismo
 No puedes ser alguien que hayas visto anteriormente

24. Función a testear
import random
users = ['Sara', 'Alexandra']
def get_next_person(user):
person = get_random_user()
while person in user['people_seen']:
person = get_random_user()
return person
def get_random_user():
return random.choice(users)

25. Unit Test
from src.next_person import get_next_person
def test_new_person():
# Arrange
user = {'people_seen': []}
expected_person = 'Alexandra'
# Action
actual_person = get_next_person(user)
# Assert
assert actual_person == expected_person

29. from src.next_person import get_next_person
from mock import patch
@patch("src.next_person.get_random_user")
def test_new_person(mock_get_random_user):
# Arrange
user = {'people_seen': []}
expected_person = 'Alexandra'
mock_get_random_user.return_value = 'Alexandra'
# Action
actual_person = get_next_person(user)
# Assert
assert actual_person == expected_person

30. Otra manera
def test_new_person():
# Arrange
app = TindevQA()
user = {'people_seen': []}
expected_person = 'Alexandra'
app.get_random_user = Mock()
app.get_random_user.return_value = 'Alexandra'
# Action
actual_person = app.get_next_person(user)
# Assert
assert actual_person == expected_person

31. Context Manager
def test_new_person_context_manager():
with patch.object(TindevQA, "get_random_user") as mock_get_random_user:
# Arrange
app = TindevQA()
user = {'people_seen': []}
expected_person = 'Alexandra'
mock_get_random_user.return_value = 'Alexandra'
# Action
actual_person = app.get_next_person(user)
# Assert
assert actual_person == expected_person

32. Varias respuestas
@patch.object(TindevQA, "get_random_user")
def test_new_person_several_times(mock_get_random_user):
app = TindevQA()
user = {'people_seen': ['Sara', 'Alexandra']}
expected_person = 'Leia'
mock_get_random_user.side_effect = ['Alexandra', 'Sara', 'Leia']
# Action
actual_person = app.get_next_person(user)
# Assert
assert actual_person == expected_person

33. Problema TinDevQA Match
 Cuando el usuario le gusta a una persona…
 Si el otro usuario le gusta
 Mandar un mail a ambos usuarios
 Cuando el otro usuario no le gusta
 Mandar un mail de no me gusta de forma civilizada
 Si el otro usuario no lo ha evaluado
 Decir que espere que el otro usuario le evalue

34. Evaluar Match
def evaluate(self, person1, person2):
if person1 in person2['likes']:
self.send_email(person1)
self.send_email(person2)
elif person1 in person2['dislikes']:
self.let_down_gently(person1)
elif person1 not in person2['likes']
and person1 not in person2['dislikes']:
self.give_it_time(person1)
NO RETURNS!!!!!

35. Comprobar que se ha llamado el
método
@patch.object(TindevQA, "let_down_gently")
def test_person2_dislikes_person1(mock_let_down):
app = TindevQA()
person1 = 'Luke'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
app.evaluate(person1, person2)
assert mock_let_down.call_count == 1

36. Comprobar los parametros
@patch.object(TindevQA, "let_down_gently")
def test_person2_dislikes_person1_parameters(mock_let_down):
app = TindevQA()
person1 = 'Luke'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
app.evaluate(person1, person2)
mock_let_down.assert_called_once_with(person1)

37. Multiple mocks
@patch.object(TindevQA, "give_it_time")
@patch.object(TindevQA, "send_email")
@patch.object(TindevQA, "let_down_gently")
def test_person2_dislikes_person1_multiple_mocks(mock_let_down, mock_send_mail,
mock_give_it_time):
app = TindevQA()
person1 = 'Luke'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
app.evaluate(person1, person2)
mock_let_down.assert_called_once_with(person1)
assert mock_send_mail.call_count == 0
assert mock_give_it_time.call_count == 0

38. Multiple calls
@patch.object(TindevQA, "send_email")
def test_person2_likes_person1( mock_send_mail):
app = TindevQA()
person1 = 'Han Solo'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
app.evaluate(person1, person2)
person1_mail_received = mock_send_mail.call_args_list[0]
person2_mail_received = mock_send_mail.call_args_list[1]
assert person1_mail_received == call(person1)
assert person2_mail_received == call(person2)

39. Mocking Exceptions and builtins
def get_information_from_file(self, filename):
try:
return json.loads(open(filename).read())
except (IOError, ValueError):
return "ERROR"

40. Testing JSON reader
 Test parseo de un fichero valido
 Test de una exception IOError
 Test de una exception ValueError

41. @patch("builtins.open")
def test_get_valid_json(mock_open):
app = TindevQA()
filename = "configuration.json"
expected_result = {'name': 'Leia', 'likes': ['Han Solo'],
'dislikes': ['Luke']}
mock_file = Mock()
mock_file.read.return_value = '{"name": "Leia", "likes": ["Han Solo"],
"dislikes": ["Luke"]}'
mock_open.return_value = mock_file
actual_result = app.get_information_from_file(filename)
assert actual_result == expected_result

42. Error Handling
@patch("builtins.open")
def test_get_information_ioerror(mock_open):
app = TindevQA()
filename = "configuration.json"
mock_open.side_effect = IOError
actual_result = app.get_information_from_file(filename)
assert actual_result == "ERROR"

43. Error Handling
@patch("json.loads")
@patch("builtins.open")
def test_get_information_valueerror(mock_open, mock_loads):
app = TindevQA()
filename = "configuration.json"
mock_file = Mock()
mock_file.read.return_value = '{"name": "Leia", "likes": ["Han Solo"],
"dislikes": ["Luke"]}'
mock_open.return_value = mock_file
mock_loads.side_effect = ValueError
actual_result = app.get_information_from_file(filename)
assert actual_result == "ERROR"

45. When… ThenReturn
def test_new_person_decorator():
# Arrange
app = TindevQA()
user = {'people_seen': []}
expected_person = 'Alexandra'
when(app).get_random_user().thenReturn('Alexandra')
# Action
actual_person = app.get_next_person(user)
# Assert
assert actual_person == expected_person

46. Multiples Respuestas
def test_new_person_several_times():
app = TindevQA()
user = {'people_seen': ['Sara', 'Alexandra']}
expected_person = 'Leia'
when(app).get_random_user().thenReturn('Alexandra', 'Sara', 'Leia')
# Action
actual_person = app.get_next_person(user)
# Assert
assert actual_person == expected_person

47. Validar que se ha llamado
def test_person2_dislikes_person1():
app = TindevQA()
person1 = 'Luke'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
when(app).let_down_gently(...)
app.evaluate(person1, person2)
verify(app, times=1).let_down_gently(...)

48. Validando los parámetros
def test_person2_dislikes_person1_parameters():
app = TindevQA()
person1 = 'Luke'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
when(app).let_down_gently(person1)
app.evaluate(person1, person2)
verify(app, times=1).let_down_gently(person1)

49. Multiple Mocks
def test_person2_dislikes_person1_multiple_mocks():
app = TindevQA()
person1 = 'Luke'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
when(app).let_down_gently(person1)
when(app).send_email(...)
when(app).give_it_time(...)
app.evaluate(person1, person2)
verify(app, times=1).let_down_gently(person1)
verify(app, times=0).send_email(...)
verify(app, times=0).give_it_time(...)

50. Multiple Calls
def test_person2_likes_person1():
app = TindevQA()
person1 = 'Han Solo'
person2 = {'name': 'Leia',
'likes': ['Han Solo'],
'dislikes': ['Luke']}
when(app).send_email(...)
app.evaluate(person1, person2)
verify(app, times=2).send_email(...)
verify(app, times=1).send_email(person1)
verify(app, times=1).send_email(person2)

51. Error Handling
def test_get_information_ioerror():
app = TindevQA()
filename = "configuration.json"
when(builtins.open(filename)).read().thenRaise(IOError)
actual_result = app.get_information_from_file(filename)
assert actual_result == "ERROR"

52. Integration Test
def send_sms(self, user, text, to):
try:
body = {'from': user, 'text': text, 'to': to,
'api_key': ‘XXXXXX', 'api_secret: ‘XXXXXXXXX'}
r = requests.post(url=URL, data=body)
return r
except Timeout:
return "ERROR"
Mandar SMS a un usuario

53. Integration Test
def test_send_sms():
app = TindevQA()
user = 'Chewbacca'
text = 'Quieres enredarte entre mis pelos?'
to = 34600000000
response = app.send_sms(user, text, to)
assert response.ok == True

54. Integration test Mocking
def test_send_sms_with_mockito():
app = TindevQA()
user = 'Chewbacca'
text = 'Quieres enredarte entre mis pelos?'
response_mock = mock({'status_code': 200, 'text': 'Ok'})
when(requests).post(...).thenReturn(response_mock)
response = app.send_sms(user, text)
assert response.status_code == 200

55. Y si no tengo acceso al código?

56. Create tu propio mock
@app.post("/sms/json")
@app.post("/sms/json")
def send_sms():
body = {'from': request.forms.get("from"),
'text': request.forms.get("text"),
'to': request.forms.get("to")}
requests_handled.append(body)
if len(response_saved) > 0:
response_to_send = response_saved.pop()
response.status = response_to_send['status_code']
return response_to_send['message']

57. Funciones para “espiar” y devolver
respuestas predefinidas
@app.post("/set_response")
def set_response():
body = b"".join(request.body)
body = json.loads(body)
response_saved.append(body)
@app.get("/stats")
def stats():
body = {'requests': list(requests_handled)}
return json.dumps(body)

58. Test usando nuestro propio mock
def test_send_sms():
app = TindevQA()
user = 'Chewbacca'
text = 'Quieres enredarte entre mis pelos?'
response = app.send_sms(user, text)
r = requests.get('http://localhost:8080/stats')
body = r.json()
assert body['requests'][0]['from'] == 'Chewbacca'
assert body['requests'][0]['to'] == ‘34000000000'
assert body['requests'][0]['text'] == 'Quieres enredarte entre mis pelos?'

59. Test forzando una respuesta errónea
def test_send_sms_with_error():
app = TindevQA()
user = 'Chewbacca'
text = 'Quieres enredarte entre mis pelos?'
data = {'status_code': 500, 'message': 'Servidor Caido'}
r = requests.post('http://localhost:8080/set_response', json=data)
response = app.send_sms(user, text)
assert response.status_code == 500
assert response.text == 'Servidor Caido'

60. Resumen
 Los mocks nos ayudan a escribir tests unitarios más
simples
 Eliminan dependencias
 Verifican comportamiento de métodos sin retorno
 Nos permiten testear errores
 Nos permiten testear más rápido
 Nos permiten testear sin que el resto de componentes
estén finalizados

61. Referencias
 https://docs.python.org/3/library/unittest.mock.html
 https://martinfowler.com/articles/practical-test-pyramid.html
 https://martinfowler.com/articles/mocksArentStubs.html
 http://xunitpatterns.com/Test%20Double.html
 http://blog.cleancoder.com/uncle-bob/2014/05/10/WhenToMock.html
 https://bottlepy.org/docs/dev/
 https://github.com/twiindan/mocking
 https://mockito-python.readthedocs.io/en/latest/

62. Preguntas?
Email: twiindan@gmail.com
Twitter: @twiindan
Linkedin: https://www.linkedin.com/in/antoniorobres