Python Service.abs_plus Examples

Example #1

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-fmachaal

class TestService(unittest.TestCase):
    def setUp(self):
        self.service = Service()

    @patch('service.Service.bad_random', return_value=9)
    def test_bad_random(self, bad_random):
        self.assertEqual(bad_random(), 9)

    def test_divide(self):
        self.service.bad_random = mock.Mock(return_value=4)
        return_val = self.service.divide(2)
        assert return_val == 2

        self.service.bad_random = mock.Mock(return_value=5)
        return_val = self.service.divide(2)
        assert return_val == 2.5

    def test_abs_plus(self):
        assert self.service.abs_plus(-1) == 2
        assert self.service.abs_plus(0) == 1
        assert self.service.abs_plus(1) == 2

    def test_complicated_function(self):
        self.service.divide = mock.Mock(return_value=15)
        self.service.bad_random = mock.Mock(return_value=6)
        assert self.service.complicated_function(5) == (15, 0)

Example #2

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-cmackenzie1

class ServiceTest(TestCase):

    def setUp(self):
        self.service = Service()

    def bad_random_mock(self):
        return 10

    @patch.object(Service, 'bad_random', bad_random_mock)
    def test_divide(self):
        assert self.service.divide(2) == 5
        assert self.service.divide(-1) == -10

    def test_abs_plus(self):
        assert self.service.abs_plus(-9) == 10
        assert self.service.abs_plus(0) == 1
        assert self.service.abs_plus(1) == 2

    @patch.object(Service, 'bad_random', bad_random_mock)
    def test_complicated_function(self):
        res1, res2 = self.service.complicated_function(10)
        assert res1 == 1
        assert res2 == 0

        res1, res2 = self.service.complicated_function(-1)
        assert res1 == -10
        assert res2 == 0

Example #3

 def test_abs_plus(self):
     x = Service()
     self.assertEqual(x.abs_plus(10), 11)
     self.assertEqual(x.abs_plus(0), 1)
     self.assertEqual(x.abs_plus(-10), 11)
     self.assertEqual(x.abs_plus(-sys.maxsize + 1), sys.maxsize)
     self.assertEqual(x.abs_plus(10), 11)

Example #4

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-shardul-shah

def test_abs_plus():
    newService = Service()

    assert newService.abs_plus(-10) == (abs(-10) + 1)
    assert newService.abs_plus(10) == (abs(10) + 1)
    assert newService.abs_plus(0) == (abs(0) + 1)
    assert newService.abs_plus(3.14) == (abs(3.14) + 1)

Example #5

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-shardul-shah

def test_abs_plus():
	newService = Service()

	assert newService.abs_plus(-10) == (abs(-10) + 1)
	assert newService.abs_plus(10) == (abs(10) + 1)
	assert newService.abs_plus(0) == (abs(0) + 1)
	assert newService.abs_plus(3.14) == (abs(3.14) + 1)

Example #6

 def testDivide(self, mockAbsPlus):
     mockAbsPlus.return_value = 10
     assert(Service.abs_plus(-9) == 10)
     mockAbsPlus.return_value = 1
     assert(Service.abs_plus(0) == 1)
     mockAbsPlus.return_value = 11
     assert(Service.abs_plus(10) == 11)

Example #7

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-htruong1

def test_abs_plus():
    serviceTest = Service()
    testValue = serviceTest.abs_plus(-5)
    assert(testValue == 6)

    testValue = serviceTest.abs_plus(0)
    assert(testValue == 1)

Example #8

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-htruong1

def test_abs_plus():
    serviceTest = Service()
    testValue = serviceTest.abs_plus(-5)
    assert (testValue == 6)

    testValue = serviceTest.abs_plus(0)
    assert (testValue == 1)

Example #9

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-cmackenzie1

class ServiceTest(TestCase):
    def setUp(self):
        self.service = Service()

    def bad_random_mock(self):
        return 10

    @patch.object(Service, 'bad_random', bad_random_mock)
    def test_divide(self):
        assert self.service.divide(2) == 5
        assert self.service.divide(-1) == -10

    def test_abs_plus(self):
        assert self.service.abs_plus(-9) == 10
        assert self.service.abs_plus(0) == 1
        assert self.service.abs_plus(1) == 2

    @patch.object(Service, 'bad_random', bad_random_mock)
    def test_complicated_function(self):
        res1, res2 = self.service.complicated_function(10)
        assert res1 == 1
        assert res2 == 0

        res1, res2 = self.service.complicated_function(-1)
        assert res1 == -10
        assert res2 == 0

Example #10

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-xmzzzz

 def test_abs_plus(self):
     s = Service()
     #s.bad_random = mock.Mock(return_value=10)
     r_val = s.abs_plus(-100)
     assert r_val == 101
     
     r_val1 = s.abs_plus(1e-9)
     assert r_val1 == 1e-9+1

Example #11

def test_abs_plus():
    service = Service()

    assert service.abs_plus(-1) == 2

    assert service.abs_plus(0) == 1

    assert service.abs_plus(1) == 2

Example #12

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-xmzzzz

    def test_abs_plus(self):
        s = Service()
        #s.bad_random = mock.Mock(return_value=10)
        r_val = s.abs_plus(-100)
        assert r_val == 101

        r_val1 = s.abs_plus(1e-9)
        assert r_val1 == 1e-9 + 1

Example #13

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-Hk-tang

 def test_abs(self):
     service = Service()
     self.assertEqual(service.abs_plus(-5), 6)
     self.assertEqual(service.abs_plus(10000000), 10000001)
     self.assertEqual(service.abs_plus(0), 1)
     try:
         service.abs_plus("hello")
         self.assertTrue(True)
     except Exception as e:
         self.assertEqual(e.__class__, TypeError)

Example #14

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-ZhimaoLin

def test_abs_plus():
    service = Service()

    # Test x > 0
    assert service.abs_plus(5) == 6

    # Test x = 0
    assert service.abs_plus(0) == 1

    # Test x < 0
    assert service.abs_plus(-3) == 4

Example #15

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-olivaC

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]

Example #16

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-Suiteprecure

    def test_abs_plus(self):
        service = Service()
        return_val = service.abs_plus(3)
        assert return_val == 4

        return_val1 = service.abs_plus(-1)
        assert return_val1 == 2

        return_val2 = service.abs_plus(0)
        assert return_val2 == 1

        # cannot abs a string
        self.assertRaises(TypeError,service.abs_plus,"")

Example #17

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-dcam4

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))

Example #18

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-IanWark

def test_abs_plus():	
	serv = Service()

	test_outputs = [1, 1.1, 1.1, 2, 2, 3, 3, 11, 11, 1001, 1001]

	# test all inputs
	for i in range(0, len(test_inputs)):
		result = serv.abs_plus(test_inputs[i])
		assert(result == test_outputs[i])

Example #19

def test_abs_plus():
    serv = Service()

    test_outputs = [1, 1.1, 1.1, 2, 2, 3, 3, 11, 11, 1001, 1001]

    # test all inputs
    for i in range(0, len(test_inputs)):
        result = serv.abs_plus(test_inputs[i])
        assert (result == test_outputs[i])

Example #20

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-hiufungk

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)       

Example #21

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)

Example #22

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-manweile

    def test_abs_plus(self):
        mockService = Service()

        #test case very large negative integer
        self.assertTrue(mockService.abs_plus(-2147483648) == 2147483649)

        #test case integer just less than zero
        self.assertTrue(mockService.abs_plus(-1) == 2)

        #test case zero
        self.assertTrue(mockService.abs_plus(0) == 1)

        #test case integer just larger than zero
        self.assertTrue(mockService.abs_plus(1) == 2)

        #test case very large positive integer
        self.assertTrue(mockService.abs_plus(2147483647) == 2147483648)

        #test case not a number
        self.assertRaises(TypeError, mockService.abs_plus, 'string')

Example #23

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-aozero

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))

Example #24

def test_abs_plus():
    service = Service()
    
    assert service.abs_plus(2) == 3
    assert service.abs_plus(0) == 1
    assert service.abs_plus(-2) == 3

Example #25

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-ybekele

 def test_abs_plus(self):
     assert Service.abs_plus(self, 1) == 2
     return

Example #26

 def test_abs_plus(self, x):
     import_serv = Service()
     absNum = import_serv.abs_plus(-4)
     self.assertEqual(absNum, 5)

Example #27

File: test_service.py Project: sidwar76/web-app-ci-cd-with-travis-ci-dong-alex

    def test_abs_plus(self):
        assert Service.abs_plus(self, -5) == 6

        assert Service.abs_plus(self, 1) == 2
        assert Service.abs_plus(self, 0) == 1
        return

Example #28

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-aabels

 def test_abs_plus(self):
     assert Service.abs_plus(self, -999) == 1000
     assert Service.abs_plus(self, 999) == 1000
     assert Service.abs_plus(self, 0) == 1
     assert Service.abs_plus(self, 11) == 12
     return

Example #29

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-ybekele

 def test_abs_plus(self):
     assert Service.abs_plus(self, 1) == 2
     return

Example #30

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-Katzesama

 def test_abs_plus(self):
     ser = Service()
     re = ser.abs_plus(10)
     assert re == 11
     re = ser.abs_plus(-20)
     assert re == 21        

Example #31

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-kieter

 def test_abs_plus(self):
     service = Service()
     assert service.abs_plus(-1) == 2

Example #32

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-forgeno

def test_abs_plus():
    service = Service()
    returnAbs = service.abs_plus(-5)
    assert (returnAbs == 6)

Example #33

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-MichaelParadis

 def test_abs_plus(self):
     service = Service()
     
     assert service.abs_plus(0) == 1
     assert service.abs_plus(-1) == 2
     assert service.abs_plus(1) == 2

Example #34

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-amalik2

class ServiceTests(unittest.TestCase):
	def setUp(self):
		self.instance = Service()
		
	def _testDivideWithValues(self, mockValue, divideArg, expected, badRandomMock):
		badRandomMock.return_value = mockValue
		assert self.instance.divide(divideArg) == expected
	
	@patch("service.Service.bad_random")
	def test_divide(self, badRandomMock):
		self._testDivideWithValues(1, 5, 0.2, badRandomMock)
		self._testDivideWithValues(0, 5, 0, badRandomMock)
		self._testDivideWithValues(5, 5, 1, badRandomMock)
		self._testDivideWithValues(-3, 5, -0.6, badRandomMock)
		self._testDivideWithValues(-2, -4, 0.5, badRandomMock)
		self._testDivideWithValues(20000, -10000, -2, badRandomMock)
		
		badRandomMock.return_value = 1
		self.assertRaises(ZeroDivisionError, self.instance.divide, 0)
		
	def test_abs_plus(self):
		assert self.instance.abs_plus(-1) == 2
		assert self.instance.abs_plus(1) == 2
		assert self.instance.abs_plus(0) == 1
		assert self.instance.abs_plus(-2) == 3
		assert self.instance.abs_plus(-2147483648) == 2147483649
		assert self.instance.abs_plus(2147483647) == 2147483648
		assert self.instance.abs_plus(0.55555) == 1.55555
		assert self.instance.abs_plus(-0.55555) == 1.55555
		self.assertRaises(TypeError, self.instance.abs_plus, "a")

	def test_complicated_function(self):
		self.instance.divide = MagicMock(25)
		self.assertRaises(TypeError, self.instance.complicated_function, 25)
		
		self.instance.divide = MagicMock(0)
		self.assertRaises(TypeError, self.instance.complicated_function, 9)
		
		self.instance.divide = MagicMock(100)
		self.assertRaises(TypeError, self.instance.complicated_function, 2)
		
		self.instance.divide = MagicMock(-25)
		self.assertRaises(TypeError, self.instance.complicated_function, 2)

	@patch("builtins.open")
	@patch("random.randint")
	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_file_error(self):
		self.assertRaises(FileNotFoundError, Service.bad_random)

Example #35

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-aabels

 def test_abs_plus(self):
     assert Service.abs_plus(self, -999) == 1000
     assert Service.abs_plus(self, 999) == 1000
     assert Service.abs_plus(self, 0) == 1
     assert Service.abs_plus(self, 11) == 12
     return

Example #36

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-machung21

 def test_abs_plus(self, x):
     import_serv = Service()
     absNum = import_serv.abs_plus(-4)
     self.assertEqual(absNum, 5)

Example #37

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-corey1994

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()

Example #38

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-amalik2

class ServiceTests(unittest.TestCase):
    def setUp(self):
        self.instance = Service()

    def _testDivideWithValues(self, mockValue, divideArg, expected,
                              badRandomMock):
        badRandomMock.return_value = mockValue
        assert self.instance.divide(divideArg) == expected

    @patch("service.Service.bad_random")
    def test_divide(self, badRandomMock):
        self._testDivideWithValues(1, 5, 0.2, badRandomMock)
        self._testDivideWithValues(0, 5, 0, badRandomMock)
        self._testDivideWithValues(5, 5, 1, badRandomMock)
        self._testDivideWithValues(-3, 5, -0.6, badRandomMock)
        self._testDivideWithValues(-2, -4, 0.5, badRandomMock)
        self._testDivideWithValues(20000, -10000, -2, badRandomMock)

        badRandomMock.return_value = 1
        self.assertRaises(ZeroDivisionError, self.instance.divide, 0)

    def test_abs_plus(self):
        assert self.instance.abs_plus(-1) == 2
        assert self.instance.abs_plus(1) == 2
        assert self.instance.abs_plus(0) == 1
        assert self.instance.abs_plus(-2) == 3
        assert self.instance.abs_plus(-2147483648) == 2147483649
        assert self.instance.abs_plus(2147483647) == 2147483648
        assert self.instance.abs_plus(0.55555) == 1.55555
        assert self.instance.abs_plus(-0.55555) == 1.55555
        self.assertRaises(TypeError, self.instance.abs_plus, "a")

    def test_complicated_function(self):
        self.instance.divide = MagicMock(25)
        self.assertRaises(TypeError, self.instance.complicated_function, 25)

        self.instance.divide = MagicMock(0)
        self.assertRaises(TypeError, self.instance.complicated_function, 9)

        self.instance.divide = MagicMock(100)
        self.assertRaises(TypeError, self.instance.complicated_function, 2)

        self.instance.divide = MagicMock(-25)
        self.assertRaises(TypeError, self.instance.complicated_function, 2)

    @patch("builtins.open")
    @patch("random.randint")
    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_file_error(self):
        self.assertRaises(FileNotFoundError, Service.bad_random)

Example #39

File: test_service.py Project: cmput401-fall2018/web-app-ci-cd-with-travis-ci-corey1994

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()