# Python OOP Exam - 14 August 2022
# https://judge.softuni.org/Contests/Practice/Index/3558#2
from project.bookstore import Bookstore
from unittest import TestCase, main
class BookstoreTests(TestCase):
# def setUp(self) -> None:
# books_limit = 10
# self.shop = Bookstore(books_limit)
# self.shop.availability_in_store_by_book_titles = {'title1': 5}
# self.shop._Bookstore__total_sold_books = 5
def test_init(self):
store = Bookstore(10)
self.assertEqual(10, store.books_limit)
self.assertEqual({}, store.availability_in_store_by_book_titles)
self.assertEqual(0, store._Bookstore__total_sold_books)
def test_total_sold_books_property_returns_proper_result(self):
store = Bookstore(10)
store.availability_in_store_by_book_titles = {'title1': 5}
store.sell_book('title1', 3)
self.assertEqual(3, store.total_sold_books)
def test_books_limit_returns_proper_result(self):
store = Bookstore(10)
self.assertEqual(10, store.books_limit)
store.books_limit = 5
self.assertEqual(5, store.books_limit)
def test_books_limit_raises_if_value_is_zero_or_below_zero(self):
with self.assertRaises(ValueError) as error:
store = Bookstore(0)
self.assertEqual(f"Books limit of 0 is not valid", str(error.exception))
with self.assertRaises(ValueError) as error:
store = Bookstore(-5)
self.assertEqual(f"Books limit of -5 is not valid", str(error.exception))
def test_len_returns_proper_result(self):
store = Bookstore(5)
self.assertEqual(0, store.__len__())
store.availability_in_store_by_book_titles = {'book1': 3}
self.assertEqual(3, store.__len__())
store.availability_in_store_by_book_titles = {'book1': 5}
self.assertEqual(5, store.__len__())
def test_receive_book_raises_if_books_limit_reached(self):
store = Bookstore(5)
store.availability_in_store_by_book_titles = {'title1': 3}
with self.assertRaises(Exception) as ex:
store.receive_book('title1', 4)
self.assertEqual("Books limit is reached. Cannot receive more books!", str(ex.exception))
def test_receive_book_if_space_is_enough(self):
store = Bookstore(10)
store.availability_in_store_by_book_titles = {'title1': 2}
store.receive_book('title1', 3)
self.assertEqual(5, store.availability_in_store_by_book_titles['title1'])
store.availability_in_store_by_book_titles = {'title1': 2}
store.receive_book('title2', 3)
self.assertEqual(3, store.availability_in_store_by_book_titles['title2'])
store.availability_in_store_by_book_titles = {'title1': 2}
self.assertEqual(f"8 copies of title1 are available in the bookstore."
, store.receive_book('title1', 6))
def test_sell_book_raises_if_book_doesnt_exist(self):
store = Bookstore(10)
with self.assertRaises(Exception) as ex:
store.sell_book('title1', 1)
self.assertEqual(f"Book title1 doesn't exist!", str(ex.exception))
def test_sell_book_raises_if_not_enough_copies_to_sell(self):
store = Bookstore(10)
store.receive_book('title1', 2)
with self.assertRaises(Exception) as ex:
store.sell_book('title1', 4)
self.assertEqual(f"title1 has not enough copies to sell. Left: 2", str(ex.exception))
def test_sell_book_if_can_sell_successfully(self):
store = Bookstore(10)
store.receive_book('title1', 5)
self.assertEqual(f"Sold 3 copies of title1", store.sell_book('title1', 3))
self.assertEqual(2, store.availability_in_store_by_book_titles['title1'])
self.assertEqual(3, store._Bookstore__total_sold_books)
def test_str_method(self):
store = Bookstore(10)
store.availability_in_store_by_book_titles = {'book1': 5, 'book2': 3}
result1 = f'Total sold books: 0\n'
result1 += f"Current availability: 8\n"
result1 += f" - book1: 5 copies\n"
result1 += f" - book2: 3 copies\n"
self.assertEqual(result1.rstrip(), str(store))
if __name__ == '__main__':
main()
===================================================================================
#Python OOP Retake Exam - 22 August 2022
# https://judge.softuni.org/Contests/Practice/Index/3591#2
from project.shopping_cart import ShoppingCart
from unittest import TestCase, main
class ShoppingCartTests(TestCase):
def test_init(self):
shopping_cart = ShoppingCart('Name', 200)
self.assertEqual('Name', shopping_cart.shop_name)
self.assertEqual(200, shopping_cart.budget)
self.assertEqual({}, shopping_cart.products)
def test_setter_name_raises_wrong_name_starts_with_lower_letter(self):
shopping_cart = ShoppingCart('Name', 200)
with self.assertRaises(ValueError) as error:
shopping_cart.shop_name = 'asd'
self.assertEqual('Shop must contain only letters and must start with capital letter!', str(error.exception))
def test_setter_name_raises_wrong_name_contains_not_isaplha(self):
shopping_cart = ShoppingCart('Name', 200)
with self.assertRaises(ValueError) as error:
shopping_cart.shop_name = 'N123'
self.assertEqual('Shop must contain only letters and must start with capital letter!', str(error.exception))
def test_add_raises_if_product_cost_too_much(self):
shopping_cart = ShoppingCart('Name', 200)
with self.assertRaises(ValueError) as error:
shopping_cart.add_to_cart('product1', 100)
self.assertEqual(f"Product product1 cost too much!", str(error.exception))
def test_add_if_added_successfully(self):
shopping_cart = ShoppingCart('Name', 200)
result = shopping_cart.add_to_cart('product1', 20)
expected = f"product1 product was successfully added to the cart!"
self.assertEqual(expected, result)
self.assertEqual(20, shopping_cart.products['product1'])
self.assertEqual({'product1': 20}, shopping_cart.products)
def test_remove_return_proper_string(self):
shopping_cart = ShoppingCart('Name', 200)
shopping_cart.products = {'product1': 20}
result = shopping_cart.remove_from_cart("product1")
expected = f"Product product1 was successfully removed from the cart!"
self.assertEqual(expected, result)
self.assertEqual({}, shopping_cart.products)
def test_remove_raises_if_product_not_in_cart(self):
shopping_cart = ShoppingCart('Name', 200)
shopping_cart.products = {'test1': 10}
with self.assertRaises(ValueError) as error:
shopping_cart.remove_from_cart('test2')
expected = f"No product with name test2 in the cart!"
self.assertEqual(expected, str(error.exception))
self.assertEqual({'test1': 10}, shopping_cart.products)
shopping_cart.products = {}
self.assertEqual({}, shopping_cart.products)
def test_buy_returns_proper_string(self):
shopping_cart = ShoppingCart('Name', 200)
shopping_cart.products = {'product1': 20, 'product2': 30}
expected = shopping_cart.buy_products()
result = f'Products were successfully bought! Total cost: 50.00lv.'
self.assertEqual(expected, result)
def test_buy_raises_if_no_enough_budget(self):
shopping_cart = ShoppingCart('Name', 200)
shopping_cart.products = {'product1': 150, 'product2': 60}
with self.assertRaises(ValueError) as error:
shopping_cart.buy_products()
expected = f"Not enough money to buy the products! Over budget with 10.00lv!"
self.assertEqual(expected, str(error.exception))
def test_add_method(self):
first = ShoppingCart('Test', 200)
first.add_to_cart('from_first', 1)
second = ShoppingCart('SecondTest', 100)
second.add_to_cart('from_second', 2)
merged = first.__add__(second)
self.assertEqual('TestSecondTest', merged.shop_name)
self.assertEqual(300, merged.budget)
self.assertEqual({'from_first': 1, 'from_second': 2}, merged.products)
if __name__ == '__main__':
main()
===================================================================================
# Python OOP Retake Exam - 18 April 2022
# https://judge.softuni.org/Contests/Practice/Index/3431#2
from project.plantation import Plantation
from unittest import TestCase, main
class PlantationTests(TestCase):
def test_init(self):
self.garden = Plantation(10)
self.assertEqual(10, self.garden.size)
self.assertEqual({}, self.garden.plants)
self.assertEqual([], self.garden.workers)
def test_raises_if_size_negative(self):
self.garden = Plantation(5)
with self.assertRaises(ValueError) as error:
self.garden.size = -1
self.assertEqual("Size must be positive number!", str(error.exception))
def test_if_worker_is_already_hired(self):
self.garden = Plantation(10)
self.garden.hire_worker('Gosho')
with self.assertRaises(ValueError) as error:
self.garden.hire_worker('Gosho')
self.assertEqual("Worker already hired!", str(error.exception))
def test_hire_worker_returns_proper_string_when_successfully_added(self):
self.garden = Plantation(10)
result = self.garden.hire_worker('Gosho')
self.assertEqual(len(self.garden.workers), 1)
self.assertEqual(f"Gosho successfully hired.", result)
def test_len_method(self):
self.garden = Plantation(10)
self.garden.hire_worker('Gosho')
self.assertEqual(0, self.garden.__len__())
self.garden.planting('Gosho', 'plant1')
self.garden.planting('Gosho', 'plant2')
self.assertEqual(2, self.garden.__len__())
def test_len_method1(self):
self.garden = Plantation(5)
self.garden.hire_worker('Gosho')
self.garden.hire_worker('Pesho')
self.garden.plants['Gosho'] = ['plant1']
self.garden.plants['Pesho'] = ['plant2']
self.assertEqual(2, self.garden.__len__())
def test_planting_raises_when_worker_not_in_workers_list_names(self):
self.garden = Plantation(10)
with self.assertRaises(ValueError) as error:
self.garden.planting('Pesho', 'plant1')
self.assertEqual(f"Worker with name Pesho is not hired!", str(error.exception))
def test_planting_raises_when_plantation_is_full(self):
self.garden = Plantation(1)
self.garden.hire_worker('Gosho')
self.garden.planting('Gosho', 'plant1')
with self.assertRaises(ValueError) as error:
self.garden.planting('Gosho', 'plant2')
self.assertEqual("The plantation is full!", str(error.exception))
def test_planting_worker_is_correct_and_make_first_planting_returns_proper_string(self):
self.garden = Plantation(5)
self.garden.hire_worker('Gosho')
self.assertEqual(f"Gosho planted it's first plant1.", self.garden.planting('Gosho', 'plant1'))
def test_planting_worker_is_correct_and_make_second_or_more_plantings_returns_proper_string(self):
self.garden = Plantation(5)
self.garden.hire_worker('Gosho')
self.garden.planting('Gosho', 'plant1')
self.assertEqual(len(self.garden.plants['Gosho']), 1)
self.assertEqual(f"Gosho planted plant2.", self.garden.planting('Gosho', 'plant2'))
def test_str_wrong_output(self):
self.assertEqual(Plantation(2).__str__().strip(), 'Plantation size: 2')
self.pl = Plantation(2)
self.pl.hire_worker('Martin')
self.pl.planting('Martin', 'Radishes')
self.assertEqual(self.pl.__str__().strip(), 'Plantation size: 2\nMartin\nMartin planted: Radishes')
def test_repr_wrong_output(self):
self.assertEqual(Plantation(2).__repr__().strip(), 'Size: 2\nWorkers:')
self.pl = Plantation(2)
self.pl.hire_worker('Martin')
self.pl.planting('Martin', 'Radishes')
self.assertEqual(self.pl.__repr__().strip(), 'Size: 2\nWorkers: Martin')
if __name__ == '__main__':
main()
===================================================================================
# Python OOP Exam - 10 April 2022
# https://judge.softuni.org/Contests/Practice/Index/3426#2
from project.movie import Movie
from unittest import TestCase, main
class MovieTests(TestCase):
NAME = 'GOT'
YEAR = 2000
RATING = 10
def setUp(self) -> None:
self.movie = Movie(self.NAME, self.YEAR, self.RATING)
def test_init(self):
self.assertEqual('GOT', self.movie.name)
self.assertEqual(2000, self.movie.year)
self.assertEqual(10, self.movie.rating)
self.assertEqual([], self.movie.actors)
self.assertEqual(0, len(self.movie.actors))
def test_wrong_name_validation_raises(self):
with self.assertRaises(ValueError) as error:
self.movie.name = ""
self.assertEqual(str(error.exception), "Name cannot be an empty string!")
def test_wrong_year_validation_raises(self):
with self.assertRaises(ValueError) as error:
self.movie.year = 1886
self.assertEqual(str(error.exception), "Year is not valid!")
def test_add_actor_when_actor_already_in_return_string(self):
self.movie.actors = ['Neo']
self.assertEqual(self.movie.add_actor('Neo'), f"Neo is already added in the list of actors!")
def test_add_actor_when_actor_not_exist_(self):
self.assertEqual(len(self.movie.actors), 0)
self.movie.add_actor('Neo')
self.assertEqual(len(self.movie.actors), 1)
self.assertEqual(self.movie.actors, ['Neo'])
self.movie.add_actor('Trinity')
self.assertEqual(len(self.movie.actors), 2)
self.assertEqual(self.movie.actors, ['Neo', 'Trinity'])
def test_gt_method(self):
self.another_movie = Movie('HOTD', 2020, 8)
result1 = self.movie > self.another_movie
result2 = self.another_movie > self.movie
self.assertEqual(result1, f'"{self.movie.name}" is better than "{self.another_movie.name}"')
self.assertEqual(result2, f'"{self.movie.name}" is better than "{self.another_movie.name}"')
def test_repr_method(self):
self.movie.add_actor('Neo')
result = []
result.append(f"Name: GOT")
result.append(f"Year of Release: 2000")
result.append(f"Rating: 10.00")
result.append(f"Cast: Neo")
self.assertEqual(self.movie.__repr__(), '\n'.join(result))
if __name__ == "__main__":
main()
===================================================================================
# Python OOP Retake Exam - 23 August 2021
# https://judge.softuni.org/Contests/Practice/Index/3093#2
from project.library import Library
from unittest import TestCase, main
class LibraryTests(TestCase):
NAME = 'name'
def setUp(self) -> None:
self.library = Library(self.NAME)
def test_init(self):
self.assertEqual('name', self.library.name)
self.assertEqual({}, self.library.books_by_authors)
self.assertEqual({}, self.library.readers)
def test_wrong_name(self):
with self.assertRaises(ValueError) as error:
self.library.name = ''
self.assertEqual('Name cannot be empty string!', str(error.exception))
def test_add_book(self):
author = 'author1'
title1 = 'title1'
title2 = 'title2'
self.library.add_book(author, title1)
self.assertEqual(True, author in self.library.books_by_authors)
self.assertEqual(True, title1 in self.library.books_by_authors[author])
self.assertEqual(1, len(self.library.books_by_authors[author]))
self.library.add_book(author, title2)
self.assertEqual(True, title2 in self.library.books_by_authors[author])
self.assertEqual(2, len(self.library.books_by_authors[author]))
def test_add_reader_when_readers_is_empty(self):
reader1 = 'reader1'
self.library.add_reader(reader1)
self.assertEqual(True, reader1 in self.library.readers)
def test_add_reader_when_reader_already_exist(self):
reader1 = 'reader1'
self.library.add_reader(reader1)
result = self.library.add_reader(reader1)
self.assertEqual(f"reader1 is already registered in the name library.", result)
self.assertEqual(1, len(self.library.readers))
self.assertTrue(True, reader1 in self.library.readers)
def test_rent_book_if_reader_not_registered(self):
reader1 = 'reader1'
reader2 = 'reader2'
author1 = 'author1'
title1 = 'title1'
self.library.readers = {reader2: []}
result = self.library.rent_book(reader1, author1, title1)
self.assertEqual(f"reader1 is not registered in the name Library.", result)
self.assertFalse(False, reader1 in self.library.readers)
self.assertEqual([], self.library.readers[reader2])
self.assertEqual(1, self.library.readers.__len__())
def test_rent_book_if_author_not_exist(self):
reader1 = 'reader1'
author1 = 'author1'
author2 = 'author2'
title1 = 'title1'
title2 = 'title2'
self.library.add_reader(reader1)
self.library.books_by_authors = {author2: [title2]}
result = self.library.rent_book(reader1, author1, title1)
self.assertEqual(f"name Library does not have any author1's books.", result)
self.assertFalse(False, author1 in self.library.books_by_authors)
self.assertEqual([], self.library.readers[reader1])
self.assertEqual([title2], self.library.books_by_authors[author2])
def test_rent_book_if_books_title_doesnt_exist(self):
reader1 = 'reader1'
author1 = 'author1'
title1 = 'title1'
title2 = 'title2'
self.library.add_reader(reader1)
self.library.add_book(author1, title1)
result = self.library.rent_book(reader1, author1, title2)
self.assertEqual(f"""name Library does not have author1's "title2".""", result)
self.assertEqual([title1], self.library.books_by_authors[author1])
def test_rent_book_remove_book_successfully(self):
reader1 = 'reader1'
author1 = 'author1'
title1 = 'title1'
title2 = 'title2'
self.library.add_reader(reader1)
self.library.add_book(author1, title1)
self.library.add_book(author1, title2)
self.assertEqual([title1, title2], self.library.books_by_authors[author1])
self.library.rent_book(reader1, author1, title1)
self.assertEqual([title2], self.library.books_by_authors[author1])
self.assertTrue(True, title2 not in self.library.books_by_authors[author1])
self.assertTrue(True, title1 in self.library.readers[reader1])
if __name__ == '__main__':
main()
===================================================================================
# Python OOP Exam - 15 August 2021
# https://judge.softuni.org/Contests/Practice/Index/3066#2
from project.pet_shop import PetShop
from unittest import TestCase, main
class PetShopTests(TestCase):
NAME = 'shop'
def setUp(self) -> None:
self.shop = PetShop(self.NAME)
def test_init(self):
self.assertEqual('shop', self.shop.name)
self.assertEqual({}, self.shop.food)
self.assertEqual([], self.shop.pets)
def test_add_food_raises_qty_0(self):
with self.assertRaises(ValueError) as error:
self.shop.add_food('dog_food', 0)
self.assertEqual("Quantity cannot be equal to or less than 0", str(error.exception))
def test_add_food_raises_if_qty_negative_number(self):
with self.assertRaises(ValueError) as error:
self.shop.add_food('dog_food', -10)
self.assertEqual("Quantity cannot be equal to or less than 0", str(error.exception))
def test_add_food_if_food_name_not_in_food_return_proper_string_when_added_successfully(self):
food1 = 'dog food'
self.assertFalse(food1 in self.shop.food)
self.assertEqual(f"Successfully added 10.00 grams of dog food.",
self.shop.add_food(food1, 10))
self.assertEqual(10, self.shop.food[food1])
def test_add_food_if_food_name_already_exist_return_proper_string_when_added_successfully(self):
food1 = 'cat food'
qty = 20
self.shop.food = {food1: qty}
self.assertTrue(food1 in self.shop.food)
self.assertEqual(f"Successfully added 20.00 grams of cat food.",
self.shop.add_food(food1, qty))
def test_add_pet_raises_when_pet_name_already_exist(self):
pet1 = 'dog'
self.shop.pets = [pet1]
with self.assertRaises(Exception) as ex:
self.shop.add_pet(pet1)
self.assertEqual("Cannot add a pet with the same name", str(ex.exception))
self.assertEqual([pet1], self.shop.pets)
def test_add_pet_returns_proper_string_if_add_is_successfully(self):
pet1 = 'dog'
pet2 = 'cat'
self.assertEqual(f"Successfully added dog.", self.shop.add_pet(pet1))
self.assertEqual([pet1], self.shop.pets)
self.assertEqual(f"Successfully added cat.", self.shop.add_pet(pet2))
self.assertEqual([pet1, pet2], self.shop.pets)
def test_feed_pet_raises_if_pet_name_not_exist(self):
food1 = 'dog food'
name1 = 'gosho'
name2 = 'pesho'
self.shop.pets = [name2]
with self.assertRaises(Exception) as ex:
self.shop.feed_pet(food1, name1)
self.assertEqual(f"Please insert a valid pet name", str(ex.exception))
self.assertFalse(name1 in self.shop.pets)
self.assertEqual([name2], self.shop.pets)
def test_feed_pet_if_food_name_not_exist_return_proper_string(self):
food1 = 'dog food'
food2 = 'cat food'
qty1 = 10
pet_name1 = 'gosho'
self.shop.pets = [pet_name1]
self.shop.food = {food1: qty1}
self.assertEqual(f'You do not have cat food', self.shop.feed_pet(food2, pet_name1))
self.assertFalse(food2 in self.shop.food)
self.assertEqual({food1: qty1}, self.shop.food)
def test_feed_pet_if_qty_is_lower_than_100_return_proper_string(self):
food1 = 'dog food'
qty1 = 99
pet_name1 = 'gosho'
self.shop.pets = [pet_name1]
self.shop.food = {food1: qty1}
self.assertEqual("Adding food...", self.shop.feed_pet(food1, pet_name1))
self.assertEqual(1099.00, self.shop.food[food1])
def test_feed_pet_successfully_return_proper_string(self):
food1 = 'dog food'
qty1 = 150
pet_name1 = 'gosho'
self.shop.pets = [pet_name1]
self.shop.food = {food1: qty1}
self.assertEqual(f"gosho was successfully fed", self.shop.feed_pet(food1, pet_name1))
self.assertEqual(50, self.shop.food[food1])
def test_repr(self):
pet_name1 = 'gosho'
pet_name2 = 'pesho'
self.shop.pets = [pet_name1, pet_name2]
result = f'Shop shop:\nPets: gosho, pesho'
self.assertEqual(result, self.shop.__repr__())
if __name__ == '__main__':
main()
===================================================================================
# Python OOP Exam - 10 April 2021
# https://judge.softuni.org/Contests/Practice/Index/2934#2
from unittest import TestCase, main
from project.train.train import Train
class TrainTests(TestCase):
TRAIN_FULL = "Train is full"
PASSENGER_EXISTS = "Passenger {} Exists"
PASSENGER_NOT_FOUND = "Passenger Not Found"
PASSENGER_ADD = "Added passenger {}"
PASSENGER_REMOVED = "Removed {}"
ZERO_CAPACITY = 0
def setUp(self) -> None:
self.train = Train('train', 10)
def test_init(self):
self.assertEqual('train', self.train.name)
self.assertEqual(10, self.train.capacity)
self.assertEqual([], self.train.passengers)
def test_add_raises_if_train_full(self):
self.train.capacity = 1
self.train.passengers = ['Gogo']
with self.assertRaises(ValueError) as error:
self.train.add('John')
self.assertEqual(self.TRAIN_FULL, str(error.exception))
self.assertEqual(1, self.train.passengers.__len__())
self.assertEqual(['Gogo'], self.train.passengers)
def test_add_raises_if_passenger_exist(self):
self.train.capacity = 5
self.train.passengers = ['Gogo', 'Pesho']
with self.assertRaises(ValueError) as error:
self.train.add('Gogo')
self.assertEqual("Passenger Gogo Exists", str(error.exception))
self.assertTrue('Gogo' in self.train.passengers)
self.assertEqual(['Gogo', 'Pesho'], self.train.passengers)
self.assertEqual(2, self.train.passengers.__len__())
def test_add_when_added_successfully_return_proper_string(self):
self.train.capacity = 5
self.train.passengers = ['Gogo', 'Pesho']
self.assertEqual("Added passenger Jivko", self.train.add('Jivko'))
self.assertTrue('Jivko' in self.train.passengers)
self.assertEqual(['Gogo', 'Pesho', 'Jivko'], self.train.passengers)
self.assertEqual(3, self.train.passengers.__len__())
def test_remove_passenger_raises_if_passanger_name_not_exist(self):
self.train.passengers = ['Go', 'Sho']
name1 = 'Pesho'
with self.assertRaises(ValueError) as error:
self.train.remove(name1)
self.assertEqual("Passenger Not Found", str(error.exception))
self.assertFalse(name1 in self.train.passengers)
self.assertEqual(['Go', 'Sho'], self.train.passengers)
self.assertEqual(2, self.train.passengers.__len__())
def test_remove_successfully_removed_return_proper_string(self):
self.train.passengers = ['Go', 'Sho']
name1 = 'Go'
self.assertEqual("Removed Go", self.train.remove(name1))
self.assertFalse(name1 in self.train.passengers)
self.assertEqual(['Sho'], self.train.passengers)
self.assertEqual(1, self.train.passengers.__len__())
if __name__ == '__main__':
main()
===================================================================================
# Python OOP Exam - 11 December 2021
# https://judge.softuni.org/Contests/Practice/Index/3305#2
from project.team import Team
from unittest import TestCase, main
class TeamTests(TestCase):
NAME = "RED"
def setUp(self) -> None:
self.team = Team(self.NAME)
def test_init(self):
self.assertEqual('RED', self.team.name)
self.assertEqual({}, self.team.members)
def test_wrong_name_raises(self):
with self.assertRaises(ValueError) as error:
new_team = Team('team123')
self.assertEqual("Team Name can contain only letters!", str(error.exception))
def test_add_member(self):
member_to_add = {'gogo': 25}
result = self.team.add_member(**member_to_add)
self.assertEqual(f"Successfully added: gogo", result)
self.assertTrue('gogo' in self.team.members.keys())
self.assertEqual(25, self.team.members['gogo'])
def test_remove_member_if_member_not_exist(self):
member_to_add = {'gogo': 25}
self.team.add_member(**member_to_add)
result = self.team.remove_member('pesho')
self.assertEqual(f"Member with name pesho does not exist", result)
self.assertFalse('pesho' in self.team.members)
def test_remove_successfully(self):
member_to_add = {'gogo': 25, 'pesho': 20}
self.team.add_member(**member_to_add)
result = self.team.remove_member('gogo')
self.assertEqual(f"Member gogo removed", result)
self.assertFalse('gogo' in self.team.members)
def test_gt_(self):
other_team = Team('BLUE')
member_to_add1 = {'stoqn': 23}
other_team.add_member(**member_to_add1)
member_to_add2 = {'gogo': 25, 'pesho': 20}
self.team.add_member(**member_to_add2)
result1 = self.team > other_team # True
result2 = other_team > self.team # False
# self.assertTrue(result1) # WRONG !
# self.assertFalse(result2) # WRONG !
self.assertEqual(True, result1)
self.assertEqual(False, result2)
def test_len_(self):
self.assertEqual(0, self.team.__len__())
member_to_add = {'gogo': 25, 'pesho': 20}
self.team.add_member(**member_to_add)
self.assertEqual(2, self.team.__len__())
self.assertTrue('gogo' in self.team.members)
self.assertTrue('pesho' in self.team.members)
self.assertEqual({'gogo': 25, 'pesho': 20}, self.team.members)
def test__add__(self):
member_to_add2 = {'gogo': 25}
self.team.add_member(**member_to_add2)
other_team = Team('BLUE')
member_to_add1 = {'stoqn': 23}
other_team.add_member(**member_to_add1)
merged_team = self.team + other_team
self.assertEqual('REDBLUE', merged_team.name)
self.assertEqual({'gogo': 25, 'stoqn': 23}, merged_team.members)
def test__str__(self):
member_to_add = {'gogo': 25, 'pesho': 20}
self.team.add_member(**member_to_add)
result = [f"Team name: RED", f"Member: gogo - 25-years old", f"Member: pesho - 20-years old"]
self.assertEqual('\n'.join(result), self.team.__str__())
if __name__ == '__main__':
main()
===================================================================================
# Python OOP Retake Exam - 23 August 2021
# https://judge.softuni.org/Contests/Practice/Index/3093#2
from project.library import Library
from unittest import TestCase, main
class LibraryTests(TestCase):
NAME = 'NAME'
def setUp(self) -> None:
self.library = Library(self.NAME)
def test_init(self):
self.assertEqual('NAME', self.library.name)
self.assertEqual({}, self.library.readers)
self.assertEqual({}, self.library.books_by_authors)
def test_wrong_name_raises(self):
with self.assertRaises(ValueError) as error:
new_lib = Library('')
self.assertEqual("Name cannot be empty string!", str(error.exception))
def test_add_book_if_author_not_exist(self):
author = 'author1'
title = 'title1'
self.library.add_book(author, title)
self.assertEqual({author: [title]}, self.library.books_by_authors)
self.assertEqual([title], self.library.books_by_authors[author])
def test_add_book_if_author_exist_but_add_new_title(self):
author = 'author'
title = 'title'
new_title = 'new title'
self.library.add_book(author, title)
self.library.add_book(author, new_title)
self.assertTrue(new_title in self.library.books_by_authors[author])
def test_add_reader_if_reader_already_exist(self):
self.library.readers = {'gogo': []}
result = self.library.add_reader('gogo')
self.assertEqual(f"gogo is already registered in the NAME library.", result)
self.assertTrue('gogo' in self.library.readers)
def test_add_reader_if_reader_not_exist(self):
self.library.add_reader('gogo')
self.assertTrue("gogo" in self.library.readers.keys())
self.assertEqual([], self.library.readers['gogo'])
def test_rent_book_if_reader_not_registered(self):
reader_name = 'gogo'
book_author = 'author'
book_title = 'title'
result = self.library.rent_book(reader_name, book_author, book_title)
self.assertEqual(f"gogo is not registered in the NAME Library.", result)
self.assertFalse(reader_name in self.library.readers.keys())
def test_rent_book_if_library_not_have_any_of_this_authors_books(self):
reader_name = 'gogo'
book_author = 'author'
book_title = 'title'
self.library.add_reader(reader_name)
result = self.library.rent_book(reader_name, book_author, book_title)
self.assertEqual(f"NAME Library does not have any author's books.", result)
self.assertFalse(book_author in self.library.books_by_authors.keys())
def test_rent_book_if_book_title_not_in_authors_books(self):
reader_name = 'gogo'
book_author = 'author'
book_title = 'title'
self.library.add_reader(reader_name)
self.library.add_book(book_author, book_title)
new_title = 'new title'
result = self.library.rent_book(reader_name, book_author, new_title)
self.assertEqual(f"""NAME Library does not have author's "new title".""", result)
self.assertFalse(new_title in self.library.books_by_authors[book_author])
def test_rent_book_successfully(self):
reader_name = 'gogo'
book_author = 'author'
book_title1 = 'title1'
book_title2 = 'title2'
self.library.add_reader(reader_name)
self.library.add_book(book_author, book_title1)
self.library.add_book(book_author, book_title2)
self.library.rent_book(reader_name, book_author, book_title2)
self.assertFalse(book_title2 in self.library.books_by_authors[book_author])
self.assertEqual([{'author': 'title2'}], self.library.readers[reader_name])
if __name__ == '__main__':
main()
===================================================================================
# Python OOP Retake Exam - 22 Aug 2020
# https://judge.softuni.org/Contests/Practice/Index/2472#2
from project.student_report_card import StudentReportCard
from unittest import TestCase, main
class StudentReportCardTests(TestCase):
STUDENT_NAME = 'Gosho'
SCHOOL_YEAR = 6
def setUp(self) -> None:
self.card = StudentReportCard(self.STUDENT_NAME, self.SCHOOL_YEAR)
def test_init(self):
self.assertEqual('Gosho', self.card.student_name)
self.assertEqual(6, self.card.school_year)
self.assertEqual({}, self.card.grades_by_subject)
def test_init_edge_case_year_1(self):
new_student = StudentReportCard('student1', 1)
self.assertEqual('student1', new_student.student_name)
self.assertEqual(1, new_student.school_year)
self.assertEqual({}, new_student.grades_by_subject)
def test_init_edge_case_year_12(self):
new_student = StudentReportCard('student2', 12)
self.assertEqual('student2', new_student.student_name)
self.assertEqual(12, new_student.school_year)
self.assertEqual({}, new_student.grades_by_subject)
def test_wrong_student_name_raises(self):
with self.assertRaises(ValueError) as error:
self.card.student_name = ''
self.assertEqual("Student Name cannot be an empty string!", str(error.exception))
def test_wrong_school_year_more_than_12_raises(self):
with self.assertRaises(ValueError) as error:
self.card.school_year = 15
self.assertEqual("School Year must be between 1 and 12!", str(error.exception))
def test_wrong_school_year_is_zero_raises(self):
with self.assertRaises(ValueError) as error:
self.card.school_year = 0
self.assertEqual("School Year must be between 1 and 12!", str(error.exception))
def test_wrong_school_year_is_negative_raises(self):
with self.assertRaises(ValueError) as error:
self.card.school_year = -5
self.assertEqual("School Year must be between 1 and 12!", str(error.exception))
def test_add_grade_without_subject(self):
subject = 'math'
grade = 5
self.card.add_grade(subject, grade)
self.assertEqual([grade], self.card.grades_by_subject[subject])
self.assertTrue(subject in self.card.grades_by_subject)
def test_add_grade_if_subject_exist(self):
subject = 'math'
grade1 = 5.50
grade2 = 4.50
self.card.add_grade(subject, grade1)
self.assertEqual(1, self.card.grades_by_subject[subject].__len__())
self.card.add_grade(subject, grade2)
self.assertEqual([grade1, grade2], self.card.grades_by_subject[subject])
self.assertTrue(grade1 in self.card.grades_by_subject[subject])
self.assertTrue(grade2 in self.card.grades_by_subject[subject])
self.assertEqual(2, self.card.grades_by_subject[subject].__len__())
def test_average_grade_return_proper_print_string(self):
self.card.grades_by_subject = {'math': [5, 5], 'info': [5, 5]}
average_grade1 = (5 + 5) / 2
average_grade2 = (5 + 5) / 2
result = [f"math: {average_grade1:.2f}", f"info: {average_grade2:.2f}"]
self.assertEqual('\n'.join(result), self.card.average_grade_by_subject())
def test_average_grade_for_all_subject_return_proper_print_string(self):
self.card.grades_by_subject = {'math': [5, 5], 'info': [5, 5]}
final_result = f"Average Grade: 5.00"
self.assertEqual(final_result, self.card.average_grade_for_all_subjects())
def test_repr(self):
self.card.grades_by_subject = {'math': [5, 5], 'info': [5, 5]}
result = f"Name: Gosho\n" \
f"Year: 6\n" \
f"----------\n" \
f"math: 5.00\n" \
f"info: 5.00\n" \
f"----------\n" \
f"Average Grade: 5.00"
self.assertEqual(result, self.card.__repr__())
if __name__ == '__main__':
main()