def test_divide(self):
mockService = Service()
#test case divisor is zero
mockService.bad_random = mock.Mock(return_value=4)
self.assertRaises(ZeroDivisionError, mockService.divide, 0)
#test case dividend is zero
mockService.bad_random = mock.Mock(return_value=0)
quotient = mockService.divide(4)
self.assertTrue(quotient == 0)
#test case dividend and divisor both same non zero value
mockService.bad_random = mock.Mock(return_value=7)
quotient = mockService.divide(7)
self.assertTrue(quotient == 1)
#test case non zero dividend and divisor different non zero value
mockService.bad_random = mock.Mock(return_value=6)
quotient = mockService.divide(3)
self.assertTrue(quotient == 2)
#test case non zero dividend and divisor not a number
mockService.bad_random = mock.Mock(return_value=9)
self.assertRaises(TypeError, mockService.divide, 'string')
def test_complicated_function(self, mock_service):
# values for divide
y = [-7, 0, 3]
# case 1
random = mock_service.bad_random.return_value = 49
mock_service.divide.return_value = random / y[0]
mock_service.complicated_function.return_value = Service.divide(
y[0]), Service.bad_random() % 2
ret = Service.complicated_function(y[0])
print(ret)
assert ret == (-7.0, 1)
# case 2
with pytest.raises(ZeroDivisionError):
mock_service.divide.return_value = random / y[1]
# will be previous value of -7.0 b/c error thrown
mock_service.complicated_function.return_value = Service.divide(
y[1]), Service.bad_random() % 2
ret1 = Service.complicated_function(y[1])
print(ret1)
assert ret1 == (-7.0, 1)
# case 3
mock_service.divide.return_value = random / y[2]
mock_service.complicated_function.return_value = Service.divide(
y[2]), Service.bad_random() % 2
ret2 = Service.complicated_function(y[2])
print(ret2)
assert ret2 == (16.333333333333332, 1)
def test_bad_random(self):
mockService = Service()
#test case good data
mockData = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10"
with patch('service.open', mock_open(read_data=mockData)):
mockService.bad_random = mock.Mock(return_value=5)
badNumber = Service.bad_random()
fileLines = mockData.count('\n') + 1
self.assertTrue(0 <= badNumber <= fileLines)
#test case file not found
self.assertRaises(FileNotFoundError, Service.bad_random)
#test case empty file
mockData = ""
with patch('service.open', mock_open(read_data=mockData)):
fileLines = mockData.count('\n') + 1
self.assertTrue(fileLines == 1)
self.assertRaises(FileNotFoundError, Service.bad_random)
#test case not a number
mockData = "A\nB\nC\nD\nE"
with patch('service.open', mock_open(read_data=mockData)):
fileLines = mockData.count('\n') + 1
self.assertTrue(fileLines == 5)
self.assertRaises(FileNotFoundError, Service.bad_random)
def test_complicated_function(self):
ser = Service()
ser.bad_random = mock.Mock(return_value=15)
re = ser.complicated_function(3)
assert re == (5, 1)
ser.bad_random = mock.Mock(return_value=15)
self.assertRaises(ZeroDivisionError, ser.complicated_function,0)
def test_bad_random(self, randintMock, mockOpen): # integers mockOpen.return_value = MockFile([1, 4, 7]) randintMock.return_value = 2 assert Service.bad_random() == 2 randintMock.assert_called_once_with(0, 2) randintMock.reset_mock() # empty mockOpen.return_value = MockFile([]) randintMock.return_value = -1 assert Service.bad_random() == -1 randintMock.assert_called_once_with(0, -1) randintMock.reset_mock() # float mockOpen.return_value = MockFile([5.2]) randintMock.return_value = 0 assert Service.bad_random() == 0 randintMock.assert_called_once_with(0, 0) randintMock.reset_mock() # non-numeric values mockOpen.return_value = MockFile([1, "a", 7]) self.assertRaises(ValueError, Service.bad_random) mockOpen.reset_mock()
def test_complicated_function(self, mock_service):
# values for divide
y = [-7, 0, 3]
# case 1
random = mock_service.bad_random.return_value = 49
mock_service.divide.return_value = random / y[0]
mock_service.complicated_function.return_value = Service.divide(y[0]), Service.bad_random() % 2
ret = Service.complicated_function(y[0])
print(ret)
assert ret == (-7.0, 1)
# case 2
with pytest.raises(ZeroDivisionError):mock_service.divide.return_value = random / y[1]
# will be previous value of -7.0 b/c error thrown
mock_service.complicated_function.return_value = Service.divide(y[1]), Service.bad_random() % 2
ret1 = Service.complicated_function(y[1])
print(ret1)
assert ret1 == (-7.0, 1)
# case 3
mock_service.divide.return_value = random / y[2]
mock_service.complicated_function.return_value = Service.divide(y[2]), Service.bad_random() % 2
ret2 = Service.complicated_function(y[2])
print(ret2)
assert ret2 == (16.333333333333332, 1)
def test_bad_random(self, randintMock, mockOpen):
# integers
mockOpen.return_value = MockFile([1, 4, 7])
randintMock.return_value = 2
assert Service.bad_random() == 2
randintMock.assert_called_once_with(0, 2)
randintMock.reset_mock()
# empty
mockOpen.return_value = MockFile([])
randintMock.return_value = -1
assert Service.bad_random() == -1
randintMock.assert_called_once_with(0, -1)
randintMock.reset_mock()
# float
mockOpen.return_value = MockFile([5.2])
randintMock.return_value = 0
assert Service.bad_random() == 0
randintMock.assert_called_once_with(0, 0)
randintMock.reset_mock()
# non-numeric values
mockOpen.return_value = MockFile([1, "a", 7])
self.assertRaises(ValueError, Service.bad_random)
mockOpen.reset_mock()
def test_bad_random(bad_random):
service = Service()
bad_random.return_value = 0
assert service.bad_random() == 0
bad_random.return_value = 2
assert service.bad_random() == 2
def test_complicated_function(self):
service = Service()
service.bad_random = mock.Mock(return_value=42)
assert service.complicated_function(3) == (42/3, 0)
service.bad_random = mock.Mock(return_value=43)
assert service.complicated_function(3) == (43/3, 1)
def test_bad_random(self, mock_service):
mock_service.return_value = 10
assert Service.bad_random() == 10
mock_service.return_value = 99
assert Service.bad_random() == 99
mock_service.return_value = 0
assert Service.bad_random() == 0
return
def test_complicated_function(self):
service = Service()
service.bad_random = mock.Mock(return_value=42)
assert service.complicated_function(3) == (42 / 3, 0)
service.bad_random = mock.Mock(return_value=43)
assert service.complicated_function(3) == (43 / 3, 1)
def test_divide(self):
ser = Service()
ser.bad_random = mock.Mock(return_value=20)
re = ser.divide(10)
assert re == 2
ser.bad_random = mock.Mock(return_value=20)
re = ser.divide(-10)
assert re == -2
ser.bad_random = mock.Mock(return_value=20)
self.assertRaises(ZeroDivisionError, ser.divide,0)
def test_divide(self):
s = Service()
s.bad_random = mock.Mock(return_value=10)
r_val = s.divide(5)
assert r_val == 2
s.bad_random = mock.Mock(return_value=1)
#r_val2 = s.divide(0)
self.assertRaises(ZeroDivisionError, s.divide, 0)
'''s.bad_random = mock.Mock(return_value=None)
class ServiceTest(TestCase):
def setUp(self):
self.service = Service()
@mock.patch('service.Service.bad_random', return_value=return_value[0])
def test_service_bad_random(self, x):
"""
Tests the bad_random function for Service.
"""
assert self.service.bad_random() == 20
@mock.patch('service.Service.bad_random', return_value=return_value[0])
def test_service_divide(self, x):
"""
Tests for the divide(x) function for Service.
"""
# Tests for Zero Division Error
try:
y = self.service.divide(0)
except ZeroDivisionError:
y = 'zero division error'
assert y == 'zero division error'
# Tests y > 0
y = self.service.divide(1)
assert y == 20
def test_service_abs_plus(self):
"""
Tests for the abs_plus(x) function for Service.
"""
# Test x < 0
assert self.service.abs_plus(-1) == 2
# Test x > 0
assert self.service.abs_plus(5) == 6
# Test x == 0
assert self.service.abs_plus(0) == 1
@mock.patch('service.Service.bad_random', return_value=return_value[0])
@mock.patch('service.Service.divide', return_value=return_value[0])
def test_service_complicated_function(self, x, y):
"""
Tests the complicated function for Service.
"""
a = self.service.bad_random()
b = self.service.divide(4)
i = self.service.complicated_function(4)
assert b == i[0]
assert a % 2 == i[1]
def test_divide(self):
s = Service()
s.bad_random = mock.Mock(return_value=10)
r_val = s.divide(5)
assert r_val == 2
s.bad_random = mock.Mock(return_value=1)
#r_val2 = s.divide(0)
self.assertRaises(ZeroDivisionError,s.divide,0)
'''s.bad_random = mock.Mock(return_value=None)
def test_bad_random(self, mock_service):
mock_service.return_value = 199
assert Service.bad_random() == 199
mock_service.return_value = 0
assert Service.bad_random() == 0
mock_service.return_value = -199
assert Service.bad_random() == -199
mock_service.return_value = "jdsalkd"
assert Service.bad_random() is not int
return
def test_bad_random(self, mock_service):
mock_service.return_value = 199
assert Service.bad_random() == 199
mock_service.return_value = 0
assert Service.bad_random() == 0
mock_service.return_value = -199
assert Service.bad_random() == -199
mock_service.return_value = "jdsalkd"
assert Service.bad_random() is not int
return
def test_bad_random(bad_random): newService = Service() bad_random.return_value = 3 assert newService.bad_random() == 3 bad_random.return_value = 0 assert newService.bad_random() == 0 bad_random.return_value = 10 assert newService.bad_random() == 10
def test_bad_random(bad_random):
newService = Service()
bad_random.return_value = 3
assert newService.bad_random() == 3
bad_random.return_value = 0
assert newService.bad_random() == 0
bad_random.return_value = 10
assert newService.bad_random() == 10
def test_divide(self):
service = Service()
service.bad_random = mock.Mock(return_value=9)
return_val = service.divide(2)
assert return_val == 4.5
# trying to divide 0
self.assertRaises(ZeroDivisionError,service.divide,0)
def test_complicated_function(self):
s = Service()
s.bad_random = mock.Mock(return_value=10)
#s.divide = mock.Mock(return_value=2)
r_val = s.complicated_function(5)
assert r_val == (2, 0)
self.assertRaises(ZeroDivisionError, s.complicated_function, 0)
def test_complicated_function(self):
s = Service()
s.bad_random = mock.Mock(return_value=10)
#s.divide = mock.Mock(return_value=2)
r_val = s.complicated_function(5)
assert r_val == (2,0)
self.assertRaises(ZeroDivisionError,s.complicated_function,0)
def test_bad_random(self):
file_content_mock1 = """10\n12\n14\n16\n18\n20\n30"""
#fake_file_path = 'file/path/mock'
newfile = mock_open(read_data=file_content_mock1)
with patch('service.open',newfile,create=True) :
number1 = Service.bad_random()
expected = len(file_content_mock1.split('\n'))
assert 0 <= number1 < expected
def test_bad_random(self):
file_content_mock1 = """10\n12\n14\n16\n18\n20\n30"""
#fake_file_path = 'file/path/mock'
newfile = mock_open(read_data=file_content_mock1)
with patch('service.open', newfile, create=True):
number1 = Service.bad_random()
expected = len(file_content_mock1.split('\n'))
assert 0 <= number1 < expected
def test_complicated(self):
service = Service()
service.bad_random = mock.Mock(return_value=5)
value = service.complicated_function(5)
self.assertRaises(ZeroDivisionError, service.divide, 0)
service.divide = mock.Mock(return_value=4)
return_val = service.complicated_function(2)
assert return_val[0] == 2
assert return_val[1] == 2.5
def test_complicated(self):
service = Service()
service.bad_random = mock.Mock(return_value = 5)
value = service.complicated_function(5)
self.assertRaises(ZeroDivisionError,service.divide,0)
service.divide = mock.Mock(return_value=4)
return_val = service.complicated_function(2)
assert return_val[0] == 2
assert return_val[1] == 2.5
def test_complicated_function(self, mock_service):
# mock the broken random function and previous divide function
y = 2
mock_service.bad_random.return_value = 10
mock_service.divide.return_value = mock_service.bad_random() / y
mock_service.complicated_function.return_value = Service.divide(
y), Service.bad_random() % 2
values = Service.complicated_function(2)
assert values[0] == 5.0
assert values[1] == 0
y = -2
mock_service.divide.return_value = mock_service.bad_random() / y
mock_service.complicated_function.return_value = Service.divide(
y), Service.bad_random() % 2
print(Service.complicated_function(2))
assert Service.complicated_function(2)[0] == -5.0
assert Service.complicated_function(2)[1] == 0
return
def test_complicated_function(self):
service = Service()
service.bad_random = mock.Mock(return_value=8)
# test divide by zero before mock divide
self.assertRaises(ZeroDivisionError,service.divide,0)
# test a normal value
service.divide = mock.Mock(return_value=9)
return_val = service.complicated_function(2)
assert return_val[0]==9
assert return_val[1]==0
def test_divide(self):
service = Service()
service.bad_random = mock.Mock(return_value=42)
y = 3
assert service.divide(y) == 42 / y
y2 = -10
assert service.divide(y2) == 42 / y2
assert service.divide(2) == 21
with pytest.raises(ZeroDivisionError):service.divide(0)
def test_divide(self):
service = Service()
service.bad_random = mock.Mock(return_value=42)
y = 3
assert service.divide(y) == 42 / y
y2 = -10
assert service.divide(y2) == 42 / y2
assert service.divide(2) == 21
with pytest.raises(ZeroDivisionError):
service.divide(0)
class TestService(unittest.TestCase):
def setUp(self):
self.serv = Service()
@patch('service.Service.bad_random', return_value=10)
def test_bad_random(self, args):
self.assertEqual(self.serv.bad_random(), 10)
@patch('service.Service.bad_random', return_value=10)
def test_divide(self, args):
self.assertEqual(self.serv.divide(5), 2)
self.assertEqual(self.serv.divide(-5), -2)
self.assertEqual(self.serv.divide(1), 10)
def test_abs_plus(self):
self.assertEqual(self.serv.abs_plus(1), 2)
self.assertEqual(self.serv.abs_plus(0), 1)
self.assertEqual(self.serv.abs_plus(-1), 2)
@patch('service.Service.bad_random', return_value=10)
def test_complicated_function(self, args):
self.assertEqual(self.serv.complicated_function(5), (2, self.serv.bad_random()%2))
class TestService(unittest.TestCase):
def setUp(self):
self.service = Service()
@patch('service.Service.bad_random')
def test_bad_random(self, mock_bad_random):
mock_bad_random.return_value = 20
#check to see if mock method works
self.assertEqual(self.service.bad_random(), 20)
@patch('service.Service.bad_random')
def test_divide(self, mock_bad_random):
mock_bad_random.return_value = 20
#positive
self.assertEqual(self.service.divide(5), 4)
#zero
with self.assertRaises(ZeroDivisionError):
self.service.divide(0)
#negative
self.assertEqual(self.service.divide(-2), -10)
def test_abs_plus(self):
#negative
self.assertEqual(self.service.abs_plus(-5), 6)
#zero
self.assertEqual(self.service.abs_plus(0), 1)
#positive
self.assertEqual(self.service.abs_plus(5), 6)
@patch('service.Service.bad_random')
def test_complicated_function(self, mock_bad_random):
mock_bad_random.return_value = 20
#test mod with a 0 result
self.assertEqual(self.service.complicated_function(5), (4,0))
mock_bad_random.return_value = 9
#test mod with a non zero result
self.assertEqual(self.service.complicated_function(3), (3,1))
class TestService(TestCase):
def setUp(self):
self.service = Service()
@patch("service.Service.bad_random", return_value=10)
def test_bad_random(self, mock_bad_random):
self.assertEqual(self.service.bad_random(),10)
@patch("service.Service.bad_random", return_value=10)
def test_divide(self, mock_bad_random):
self.assertEqual(self.service.divide(2), 5)
try:
self.service.divide(0)
self.assertEqual(True, False)
except:
self.assertEqual(True, True)
try:
self.service.divide("sghf")
self.assertEqual(True, False)
except:
self.assertEqual(True, True)
def test_abs_plus(self):
self.assertEqual(self.service.abs_plus(-1), 2)
self.assertEqual(self.service.abs_plus(0), 1)
self.assertEqual(self.service.abs_plus(1), 2)
try:
self.service.abs_plus("jksdfhhdfbd")
self.assertEqual(True, False)
except:
self.assertEqual(True, True)
@patch("service.Service.bad_random")
def test_complicated_function(self, mock_bad_random):
mock_bad_random.return_value = 10
rv1, rv2 = self.service.complicated_function(2)
self.assertEqual(rv1, 5)
self.assertEqual(rv2, 0)
mock_bad_random.return_value = 11
rv1, rv2 = self.service.complicated_function(2)
self.assertEqual(rv1, 5.5)
self.assertEqual(rv2, 1)
class TestService(TestCase):
def setUp(self):
self.service = Service()
@patch("service.Service.bad_random", return_value=10)
def test_bad_random(self, mock_bad_random):
self.assertEqual(self.service.bad_random(), 10)
@patch("service.Service.bad_random", return_value=10)
def test_divide(self, mock_bad_random):
self.assertEqual(self.service.divide(2), 5)
try:
self.service.divide(0)
self.assertEqual(True, False)
except:
self.assertEqual(True, True)
try:
self.service.divide("sghf")
self.assertEqual(True, False)
except:
self.assertEqual(True, True)
def test_abs_plus(self):
self.assertEqual(self.service.abs_plus(-1), 2)
self.assertEqual(self.service.abs_plus(0), 1)
self.assertEqual(self.service.abs_plus(1), 2)
try:
self.service.abs_plus("jksdfhhdfbd")
self.assertEqual(True, False)
except:
self.assertEqual(True, True)
@patch("service.Service.bad_random")
def test_complicated_function(self, mock_bad_random):
mock_bad_random.return_value = 10
rv1, rv2 = self.service.complicated_function(2)
self.assertEqual(rv1, 5)
self.assertEqual(rv2, 0)
mock_bad_random.return_value = 11
rv1, rv2 = self.service.complicated_function(2)
self.assertEqual(rv1, 5.5)
self.assertEqual(rv2, 1)
def test_complicated_function(self):
mockService = Service()
#Test case negative odd integer dividend
mockService.divide = mock.Mock(return_value=5)
mockService.bad_random = mock.Mock(return_value=-5)
modulus = mockService.complicated_function(1)
self.assertTrue(modulus == (5, 1))
#Test case negative even integer dividend
mockService.divide = mock.Mock(return_value=6)
mockService.bad_random = mock.Mock(return_value=-6)
modulus = mockService.complicated_function(1)
self.assertTrue(modulus == (6, 0))
#Test case zero dividend
mockService.divide = mock.Mock(return_value=4)
mockService.bad_random = mock.Mock(return_value=0)
modulus = mockService.complicated_function(1)
self.assertTrue(modulus == (4, 0))
#Test case positive odd integer dividend
mockService.divide = mock.Mock(return_value=5)
mockService.bad_random = mock.Mock(return_value=5)
modulus = mockService.complicated_function(1)
self.assertTrue(modulus == (5, 1))
#Test case positive even integer dividend
mockService.divide = mock.Mock(return_value=6)
mockService.bad_random = mock.Mock(return_value=6)
modulus = mockService.complicated_function(1)
self.assertTrue(modulus == (6, 0))
#test case dividend not a number
mockService.divide = mock.Mock(return_value=7)
mockService.bad_random = mock.Mock(return_value="A")
self.assertRaises(TypeError, mockService.complicated_function,
'string')
def test_bad_random(self, mock_bad_random):
mock_bad_random.return_value = 10
randNum = Service.bad_random()
self.assertEqual(randNum, 10)
class TestService(unittest.TestCase):
def setUp(self):
self.service = Service()
@patch('service.Service.bad_random')
def test_bad_random(self, mock_bad_random):
mock_bad_random.return_value = 10
self.assertEqual(self.service.bad_random(), 10)
@patch('service.Service.bad_random')
def test_divide(self, mock_bad_random):
mock_bad_random.return_value = 10
# Divisor and dividend are positive, whole result
self.assertEqual(self.service.divide(5), 2)
# Divisor and dividend are positive, fractional result
self.assertEqual(self.service.divide(20), 0.5)
# Divide by 0
with self.assertRaises(ZeroDivisionError):
self.service.divide(0)
# Positive dividend and negative divisor
self.assertEqual(self.service.divide(-5), -2)
mock_bad_random.return_value = -10
# Negative dividend and positive divisor
self.assertEqual(self.service.divide(5), -2)
# Missing argument
with self.assertRaises(TypeError):
self.service.divide()
def test_abs_plus(self):
# Negative
self.assertEqual(self.service.abs_plus(-1), 2)
# 0
self.assertEqual(self.service.abs_plus(0), 1)
# Positive
self.assertEqual(self.service.abs_plus(1), 2)
# Non-integer
with self.assertRaises(TypeError):
self.service.abs_plus('a')
# No argument
with self.assertRaises(TypeError):
self.service.abs_plus()
@patch('service.Service.divide')
@patch('service.Service.bad_random')
def test_complicated_function(self, mock_bad_random, mock_divide):
mock_divide.return_value = 5
# Sanity test, with even "random" number
mock_bad_random.return_value = 20
(a, b) = self.service.complicated_function(3)
self.assertEqual(a, 5)
self.assertEqual(b, 0)
# Odd "random" number
mock_bad_random.return_value = 19
(a, b) = self.service.complicated_function(3)
self.assertEqual(b, 1)
# Negative even "random" number
mock_bad_random.return_value = -20
(a, b) = self.service.complicated_function(3)
self.assertEqual(b, 0)
# Negative odd "random" number
mock_bad_random.return_value = -19
(a, b) = self.service.complicated_function(3)
self.assertEqual(b, 1)
# No argument
with self.assertRaises(TypeError):
self.service.complicated_function()
def test_bad_random(self, bad_random):
service = Service()
self.assertEqual(service.bad_random(), 10)
def test_bad_random(self, bad_random):
service = Service()
assert service.bad_random() == 10
def test_bad_random(self, mock_bad_random):
mock_bad_random.return_value = 10
randNum = Service.bad_random()
self.assertEqual(randNum, 10)
def test_bad_random(self, mock_service):
mock_service.return_value = 10
assert Service.bad_random() == 10
return
def test_bad_random(self, bad_random):
service = Service()
assert service.bad_random() == 10
def service_w_mocked_random():
serv = Service()
serv.bad_random = Mock('bad_random')
serv.bad_random.return_value = 10
return serv
def test_bad_random(self, mock_bad_random):
mock_bad_random.return_value = 10
assert Service.bad_random() == 10
def service_w_mocked_random():
serv = Service()
serv.bad_random = Mock('bad_random')
serv.bad_random.return_value = 10
return serv
def test_divide(self):
service = Service()
service.bad_random = mock.Mock(return_value=5)
value = service.divide(5)
assert value == 1
def test_complicated_function(self, bad_random):
mock_service.bad_random.return_value = 0
mock_service.divide.return_value = 10
final = Service_divide(0), Service.bad_random()
assert final[0] == 0
assert final[1] == 10
def test_complicated_function(self, bad_random):
mock_service.bad_random.return_value = 0
mock_service.divide.return_value = 10
final = Service_divide(0), Service.bad_random()
assert final[0] == 0
assert final[1] == 10
def test_divide(self):
service = Service()
service.bad_random = mock.Mock(return_value = 5)
value = service.divide(5)
assert value == 1
class TestService(unittest.TestCase):
def setUp(self):
self.service = Service()
@patch('service.Service.bad_random')
def test_bad_random(self, mock_bad_random):
mock_bad_random.return_value = 10
self.assertEqual(self.service.bad_random(), 10)
@patch('service.Service.bad_random')
def test_divide(self, mock_bad_random):
mock_bad_random.return_value = 10
# Divisor and dividend are positive, whole result
self.assertEqual(self.service.divide(5), 2)
# Divisor and dividend are positive, fractional result
self.assertEqual(self.service.divide(20), 0.5)
# Divide by 0
with self.assertRaises(ZeroDivisionError):
self.service.divide(0)
# Positive dividend and negative divisor
self.assertEqual(self.service.divide(-5), -2)
mock_bad_random.return_value = -10
# Negative dividend and positive divisor
self.assertEqual(self.service.divide(5), -2)
# Missing argument
with self.assertRaises(TypeError):
self.service.divide()
def test_abs_plus(self):
# Negative
self.assertEqual(self.service.abs_plus(-1), 2)
# 0
self.assertEqual(self.service.abs_plus(0), 1)
# Positive
self.assertEqual(self.service.abs_plus(1), 2)
# Non-integer
with self.assertRaises(TypeError):
self.service.abs_plus('a')
# No argument
with self.assertRaises(TypeError):
self.service.abs_plus()
@patch('service.Service.divide')
@patch('service.Service.bad_random')
def test_complicated_function(self, mock_bad_random, mock_divide):
mock_divide.return_value = 5
# Sanity test, with even "random" number
mock_bad_random.return_value = 20
(a, b) = self.service.complicated_function(3)
self.assertEqual(a, 5)
self.assertEqual(b, 0)
# Odd "random" number
mock_bad_random.return_value = 19
(a, b) = self.service.complicated_function(3)
self.assertEqual(b, 1)
# Negative even "random" number
mock_bad_random.return_value = -20
(a, b) = self.service.complicated_function(3)
self.assertEqual(b, 0)
# Negative odd "random" number
mock_bad_random.return_value = -19
(a, b) = self.service.complicated_function(3)
self.assertEqual(b, 1)
# No argument
with self.assertRaises(TypeError):
self.service.complicated_function()
