<div align="center">

<h1>Unittest</h1>

</div>

<div align="justify">

This repository contains a set of Python unit tests for testing the functionality of the code. Unit tests are automatically executed test scripts that check the correct operation of certain parts of the code, such as functions, classes, modules, and other components.

<br>

The main features of the repository:

- A set of diverse unit tests that cover various aspects of the functionality of the code

- Using Python's standard unittest module to write and run unit tests

- Examples of using the unittest.mock library to create mock objects and simulate the behavior of dependencies in tests

- Coverage of various types of testing such as positive testing, negative testing, exception testing and other scenarios

- Clear organization of tests into structured test classes and methods for easy navigation and maintenance of the test suite

- etc.

<br>

The purpose of this repository is to provide examples of Python unit tests that you can use to test your code and ensure it works correctly.

</div>

import unittest

import warnings

class MyTests(unittest.TestCase):

def test_assert_equal(self):

self.assertEqual(2 + 2, 4) # Check for equality

def test_assert_not_equal(self):

self.assertNotEqual(2 + 2, 5) # Check for inequality

def test_assert_true(self):

self.assertTrue(2 + 2 == 4) # Truth check

def test_assert_false(self):

self.assertFalse(2 + 2 == 5) # False check

def test_assert_is(self):

a = [1, 2, 3]

b = a

self.assertIs(a, b) # Check for identity of objects

def test_assert_is_not(self):

a = [1, 2, 3]

b = [1, 2, 3]

self.assertIsNot(a, b) # Check for non-identity of objects

def test_assert_in(self):

a = [1, 2, 3]

self.assertIn(2, a) # Check for the presence of an element in the sequence

def test_assert_not_in(self):

a = [1, 2, 3]

self.assertNotIn(4, a) # Check for the absence of an element in the sequence

def test_assert_is_none(self):

a = None

self.assertIsNone(a) # Check for equality with None

def test_assert_is_not_none(self):

a = 42

self.assertIsNotNone(a) # Test for inequality with None

def test_assert_almost_equal(self):

self.assertAlmostEqual(0.1 + 0.2, 0.3, delta=0.00001) # Check for approximate equality of numbers with a given delta

def test_assert_not_almost_equal(self):

self.assertNotAlmostEqual(0.1 + 0.2, 0.3, places=20) # delta=0.00001 or places=20 Check for non-approximate equality of numbers with a given delta

def test_assert_raises(self):

with self.assertRaises(ValueError): # Check for a specific exception

int("abc")

def test_assert_warns(self):

with self.assertWarns(DeprecationWarning):

warnings.warn("This function is deprecated", DeprecationWarning) # Check for a specific warning

def test_assert_regex(self):

self.assertRegex("hello world", r'hello') # Check for regular expression match

def test_assert_not_regex(self):

self.assertNotRegex("hello world", r'goodbye') # Check for non-matching regular expression

if __name__ == '__main__':

unittest.main()

def get_country(iso_code=None):

country_dict = {

'US': {

'name': 'United States of America'

},

'CA': {

'name': 'Canada'

},

'UK': {

'name': 'United Kingdom'

},

'DE': {

'name': 'Germany'

},

'JP': {

'name': 'Japan'

},

'AU' : {

'name' : 'Australia'

}

}

if type(iso_code) != str:

raise TypeError('iso_code need to be a string')

elif len(iso_code) != 2:

raise ValueError('iso_code need to be 2 characters long')

if iso_code in country_dict:

return True, country_dict[iso_code]

else:

return False, None

import unittest

from Lib.Сountry import get_country

class TestLibraryСountry(unittest.TestCase):

def test_allow_country(self):

# Testing allowed countries

iso_code_test_list = ['US', 'CA', 'UK', 'DE', 'JP', 'AU']

for iso_code in iso_code_test_list:

country = get_country(iso_code=iso_code)

self.assertTrue(country[0]) # Check if the first element of the tuple is True

self.assertEqual(dict, type(country[1])) # Check if the second element of the tuple is a dictionary

def test_disallow_country(self):

# Testing a banned country

country = get_country(iso_code='BR')

self.assertFalse(country[0]) # Check if the first element of the tuple is False

self.assertEqual(None, country[1]) # Check if the second element of the tuple is None

def test_raise_country_TypeError(self):

# Testing for throwing a TypeError exception when the function is used incorrectly

with self.assertRaises(TypeError):

get_country() # Throw TypeError without passing arguments

get_country(iso_code=12) # Throw a TypeError with a numeric argument

def test_raise_country_ValueError(self):

# Testing for throwing a ValueError exception when passing an invalid iso_code argument value

with self.assertRaises(ValueError):

get_country(iso_code='Japan') # Throw a ValueError with an invalid iso_code value

get_country(iso_code='J') # Throw a ValueError with a short iso_code value

get_country(iso_code='') # Throw a ValueError passing an empty string as the value of iso_code

import datetime

class Person:

def allowed_to_buy_alcohol(self, birthday, alcohol_percentage):

# age 16-18: < 16.5%

# age 18 and over: > 16.5%

age = self.calculate_age(birthday)

return age >= 18 and alcohol_percentage > 16.5

def allowed_to_buy_tobacco(self, birthday):

# age 18 and over

age = self.calculate_age(birthday)

return age >= 18

def calculate_age(self, birthday):

today = datetime.date.today()

birthdate = datetime.datetime.strptime(birthday, '%Y-%m-%d').date()

age = today.year - birthdate.year - ((today.month, today.day) < (birthdate.month, birthdate.day))

return age

import unittest

from Lib.Person import Person

class TestAllowedToBuyAlcohol(unittest.TestCase):

def setUp(self):

# Set up the test by creating a Person object

self.__person = Person()

def tearDown(self):

# Clean up the test by deleting the Person object

del self.__person

def test_age_are_too_low_to_buy(self):

# Test case to check if a person with age below the legal limit cannot buy alcohol

result = self.__person.allowed_to_buy_alcohol('2008-01-01', 4.6)

self.assertFalse(result)

print("Test result: Sale is not allowed. (age: too low)")

def test_age_is_allowed_to_buy(self):

# Test case to check if a person with age above the legal limit can buy alcohol

result = self.__person.allowed_to_buy_alcohol('1980-01-01', 46.6)

self.assertTrue(result)

print("Test result: Sale is allowed. (age: allowed)")

def test_age_is_allowed_to_buy_tobacco(self):

# Test case to check if a person with age above the legal limit can buy tobacco

result = self.__person.allowed_to_buy_tobacco('2000-01-01')

self.assertTrue(result)

print("Test result: Sale is allowed. (age: allowed)")

def test_age_is_not_allowed_to_buy_tobacco(self):

# Test case to check if a person with age below the legal limit cannot buy tobacco

result = self.__person.allowed_to_buy_tobacco('2015-01-01')

self.assertFalse(result)

print("Test result: Sale is not allowed. (age: too low)")

if __name__ == '__main__':

unittest.main()

class Discount:

def __init__(self, discount_rate):

self.discount_rate = discount_rate

self.discounted_categories = ['phone', 'laptop', 'tv']

def apply_discount(self, price, category):

if category in self.discounted_categories:

return price * (1 - self.discount_rate)

else:

return price