Commit 1be1f419 authored by Ernesto Crespo's avatar Ernesto Crespo

creado pruebas unitarias y cobertura con nosetests

parent 495561ca
......@@ -3,14 +3,18 @@ WORKDIR /code/
RUN pip3 install --upgrade pip
RUN pip3 install nose
#RUN pip3 install nose-cov
RUN pip3 install nose-cov
RUN pip3 install rednose
RUN pip3 install pytest
RUN pip3 install pytest-cov
RUN pip3 install mock
#EXPOSE 5000
ADD . /code/
COPY . /code/
#CMD nosetests -sv --rednose --with-coverage test/unit/calculadora_test.py
#CMD nosetests -sv --rednose test/unit/calculadora_test.py
CMD nosetests --rednose
CMD nosetests --with-coverage
#CMD nosetests -sv --rednose
This diff is collapsed.
#!/usr/bin/env python
import math
#Se importa sqrt de math
from math import sqrt
#Clase calculadora
class Calculadora:
#Metodo suma de x y y, se evalua si son enteros si no, devuelve error.
def suma(self,x,y):
if type(x) == int and type(y) == int:
return x + y
else:
raise TypeError("Invalid type: {} and {}".format(type(x),type(y)))
#Metodo raizcuadrada de X, devuelve la raiz cuadrada si es entero positivo, si no
#devuelve mensaje de error.
def raizCuadrada(self,x):
if type(x) == int and x >= 0:
return math.sqrt(x)
......@@ -18,6 +22,8 @@ class Calculadora:
if __name__ == '__main__':
#Se crea una instancia de la clase
calc = Calculadora()
#Se calcula la suma de 2 y 2, se muestra en pantalla.
results = calc.sum(2, 2)
print (results)
tutorial-pruebas:
pruebas:
build: .
ports:
- "5000:5000"
volumes:
- ".:/code"
import unittest
from mock import Mock
class TestMocking(unittest.TestCase):
def test_mock_method_returns(self):
my_mock = Mock()
my_mock.my_method.return_value = "hello"
self.assertEqual("hello", my_mock.my_method())
if __name__ == '__main__':
unittest.main()
......@@ -8,86 +8,92 @@ class TestCalculadora(unittest.TestCase):
def setUp(self):
self.calc = Calculadora()
def test_add_method_returns_correct_result(self):
def test_suma_retorna_resultado_correcto(self):
##Asegura que sea igual la operacion de suma 2+2 a 4
self.assertEqual(4, self.calc.suma(2,2))
def test_add_method_raises_typeerror_if_not_ints(self):
def test_suma_devuelve_error_si_el_tipo_no_es_entero(self):
#Asegura error, si es de tipo, cuando se le pasa dos string.
self.assertRaises(TypeError, self.calc.suma, "Hello", "World")
def test_assert_true(self):
def test_asegura_que_sea_verdadero(self):
#Se asegura que el valor 1 es true y un string.
self.assertTrue(1)
self.assertTrue("Hello, World")
def test_assert_false(self):
def test_aseura_que_sea_falso(self):
#Se asegura que el string vacio y cero son falso.
self.assertFalse(0)
self.assertFalse("")
def test_assert_greater(self):
def test_asegura_que_es_mayor(self):
#Se asegura que 2>1
self.assertGreater(2, 1)
def test_assert_greater_equal(self):
def test_asegura_que_es_mayor_e_igual(self):
#Se asegura que 2>=2
self.assertGreaterEqual(2, 2)
def test_assert_almost_equal_delta_0_5(self):
def test_asegura_que_es_casi_igual_a_delta_0_5(self):
#Se asegura que sea casi igual 1 y 1.2 con delta de 0.5
self.assertAlmostEqual(1, 1.2, delta=0.5)
def test_assert_almost_equal_places(self):
def test_asegura_lugares_casi_igual(self):
#Se asegura que es casi igual 1 y 1.00001 por 4 lugares.
self.assertAlmostEqual(1, 1.00001, places=4)
def test_assert_raises(self):
self.assertRaises(ValueError, int, "a")
def test_assert_raises_alternative(self):
with self.assertRaises(AttributeError):
[].get
def test_assert_dict_contains_subset(self):
expected = {'a': 'b'}
def test_asegura_diccionario_contiene_subconjunto(self):
esperado = {'a': 'b'}
actual = {'a': 'b', 'c': 'd', 'e': 'f'}
self.assertDictContainsSubset(expected, actual)
#Se asegura que el diccionario actual contiene lo esperado.
self.assertDictContainsSubset(esperado, actual)
def test_assert_dict_equal(self):
expected = {'a': 'b', 'c': 'd'}
def test_asegura_diccionarios_iguales(self):
esperado = {'a': 'b', 'c': 'd'}
actual = {'c': 'd', 'a': 'b'}
self.assertDictEqual(expected, actual)
#Se asegra que el diccionario esperado sea igual al actual.
self.assertDictEqual(esperado, actual)
def test_assert_in(self):
def test_asegura_que_esta_en(self):
#Se asegura que 1 este en la lista
self.assertIn(1, [1,2,3,4,5])
def test_assert_is(self):
def test_asegura_expresiones_iguales(self):
#Se asegura que las expresiones son iguales expre1 y expre2
self.assertIs("a", "a")
def test_assert_is_instance(self):
self.assertIsInstance(1, int)
def test_asegura_objeto_es_instancia_de_una_clase(self):
#Se asegura que el objeto 2 sea de la clase entero
self.assertIsInstance(2, int)
def test_assert_is_not_instance(self):
self.assertNotIsInstance(1, str)
def test_asegura_objeto_no_es_instancia_de_una_clase(self):
#Se asegura que el objeto 2 no sea una clase str
self.assertNotIsInstance(2, str)
def test_assert_is_none(self):
def test_asegura_que_es_none(self):
#Se asegura que es None.
self.assertIsNone(None)
def test_assert_is_not(self):
def test_asegura_expresiones_no_sean_iguales(self):
self.assertIsNot([], [])
def test_assert_is_not_none(self):
def test_asegura_que_no_sea_none(self):
#Se asegura que 1 no es None.
self.assertIsNotNone(1)
def test_assert_less(self):
self.assertLess(1, 2)
def test_assert_less_equal(self):
self.assertLessEqual(2, 2)
def test_asegura_que_es_menor(self):
#Se asegura que 3 es menor que 5
self.assertLess(3, 5)
# def test_assert_items_equal(self):
# self.assertItemsEqual([1,2,3], [3,1,2])
def test_asegura_que_es_menor_e_igual(self):
#Se asegura que 7 es menor o igual que 7.
self.assertLessEqual(7, 7)
def test_assert_raises(self):
self.assertRaises(IndexError, [].pop, 0)
if __name__ == '__main__':
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment