def test_text_content_is_mandatory(self):
"""
In the constructor, the text_content parameter should be
a string which is not empty
"""
self.assertRaises(TypeError, orderStep, key=1, order=self.order.key)
invalid_data = utilities.replace_value_in_dict(self.order_step_data,
'text_content', 7)
self.assertRaises(TypeError, orderStep, **invalid_data)
invalid_data = utilities.replace_value_in_dict(self.order_step_data,
'text_content', '')
self.assertRaises(ValueError, orderStep, **invalid_data)
invalid_data = utilities.replace_value_in_dict(self.order_step_data,
'text_content', ' ')
self.assertRaises(ValueError, orderStep, **invalid_data)
def test_save_method(self):
"""
The save() method should be able to update the parent order's
list of order_steps as well as that of the database
"""
self.assertIsInstance(self.order_step, orderStep)
self.order_step.save(self.db)
length_of_db_order_step_keys = len(self.db.order_step_keys)
length_of_order_steps = len(self.order.order_steps)
self.assertIn(self.order_step.key, self.db.order_step_keys)
self.assertEqual(self.order_step,
self.db.order_steps[self.order_step.key])
self.assertIn(self.order_step.key, self.order.order_steps)
# the order should exist in database
invalid_data = utilities.replace_value_in_dict(self.order_step_data,
'order', 78)
new_order_step = orderStep(**invalid_data)
self.assertRaises(KeyError, new_order_step.save, self.db)
# database parameter should be of type Database
self.assertRaises(TypeError, self.order_step.save,
'string instead of Database object')
# calling save more than once does not increase size of self.db.order_step_keys
self.order_step.save(self.db)
self.assertEqual(len(self.db.order_step_keys),
length_of_db_order_step_keys)
# calling save more than once does not increase size of self.order.order_steps
self.assertEqual(len(self.order.order_steps), length_of_order_steps)
def test_save_method(self):
"""
The save() method should be able to update the parent category's
list of orders as well as that of the database
"""
self.assertIsInstance(self.order, order)
self.order.save(self.db)
length_of_db_order_keys = len(self.db.order_keys)
length_of_category_orders = len(self.category.orders)
self.assertIn(self.order.key, self.db.order_keys)
self.assertEqual(self.order, self.db.orders[self.order.key])
self.assertIn(self.order.key, self.category.orders)
self.assertIn(self.order.name, self.db.order_name_key_map.keys())
self.assertEqual(self.order.key,
self.db.order_name_key_map[self.order.name])
# the category should exist in database
invalid_data = utilities.replace_value_in_dict(self.order_data,
'category', 78)
new_order = order(**invalid_data)
self.assertRaises(KeyError, new_order.save, self.db)
# database parameter should be of type Database
self.assertRaises(TypeError, self.order.save,
'string instead of Database object')
# calling save more than once does not increase size of self.db.order_keys
self.order.save(self.db)
self.assertEqual(len(self.db.order_keys), length_of_db_order_keys)
# calling save more than once does not increase size of self.category.orders
self.assertEqual(len(self.category.orders), length_of_category_orders)
def test_get_all_steps(self):
"""The get_all_steps function should be able to retrieve all steps"""
text_content_tuple = ('Chicken', 'Pizza', 'Mushroom Soup')
# create three order steps
created_order_steps = []
# incase an order step is ever created in the Setup
key = 2
# save order in db
self.order.save(self.db)
for text_content in text_content_tuple:
new_data = utilities.replace_value_in_dict(self.order_step_data,
'text_content',
text_content)
new_order_step = orderStep(**new_data,
key=key,
order=self.order.key)
new_order_step.save(self.db)
created_order_steps.append(new_order_step)
key += 1
order_steps = self.order.get_all_steps(self.db)
self.assertIsInstance(order_steps, list)
self.assertEqual(len(self.order.order_steps), len(order_steps))
self.assertListEqual(created_order_steps, order_steps)
self.assertRaises(TypeError, self.order.get_all_steps,
'expected Database object not string')
def test_name_is_mandatory(self):
"""
In the constructor, the name parameter should be
a string which is not empty
"""
self.assertRaises(TypeError,
order,
key=1,
description='',
category=self.category.key)
invalid_data = utilities.replace_value_in_dict(self.order_data, 'name',
7)
self.assertRaises(TypeError, order, **invalid_data)
invalid_data = utilities.replace_value_in_dict(self.order_data, 'name',
'')
self.assertRaises(ValueError, order, **invalid_data)
invalid_data = utilities.replace_value_in_dict(self.order_data, 'name',
' ')
self.assertRaises(ValueError, order, **invalid_data)
def test_replace_value_in_dict(self):
"""
replace_value_in_dict returns a new dict with value for key passed changed
replace_value_in_dict raises TypeError if dict passed in is not dict
replace_value_in_dict raises KeyError if key in dict is non existent
"""
original_dict = {'title': 'foo'}
new_dict = utilities.replace_value_in_dict(original_dict, 'title',
'bar')
self.assertEqual(new_dict['title'], 'bar')
self.assertRaises(TypeError,
utilities.replace_value_in_dict,
the_dict='a string',
key='title',
new_value='bar')
self.assertRaises(KeyError,
utilities.replace_value_in_dict,
the_dict=original_dict,
key='random',
new_value='bar')
def test_get_all_orders(self):
"""The get_all_orders function should be able to retrieve all orders"""
names = ('Banana cake', 'fruit cake', 'icy cake')
# create three orders
created_orders = []
# incase a order is ever created in the Setup
key = 2
# save category in db
self.category.save(self.db)
for name in names:
new_data = utilities.replace_value_in_dict(self.order_data, 'name',
name)
new_order = order(**new_data, key=key, category=self.category.key)
new_order.save(self.db)
created_orders.append(new_order)
key += 1
orders = self.category.get_all_orders(self.db)
self.assertIsInstance(orders, list)
self.assertEqual(len(self.category.orders), len(orders))
self.assertListEqual(created_orders, orders)
self.assertRaises(TypeError, self.category.get_all_orders,
'expected Database object not string')
def test_user_can_get_categories(self):
"""User can get a list of their order categories"""
names = ('cakes', 'bread', 'juice')
# create three categories
created_categories = []
key = 2
# save user in db
self.user.save(self.db)
for name in names:
new_data = utilities.replace_value_in_dict(self.category_data,
'name', name)
new_category = orderCategory(**new_data,
key=key,
user=self.user.key)
new_category.save(self.db)
created_categories.append(new_category)
key += 1
categories = self.user.get_all_order_categories(self.db)
self.assertIsInstance(categories, list)
self.assertEqual(len(self.user.order_categories), len(categories))
self.assertListEqual(created_categories, categories)
self.assertRaises(TypeError, self.user.get_all_order_categories,
'expected Database object not string')
def test_key_is_int(self):
"""The key should be an int"""
invalid_data = utilities.replace_value_in_dict(self.user_data, 'key',
'string_key')
self.assertRaises(TypeError, User, **invalid_data)
def test_password_is_string(self):
"""The password should be a string"""
invalid_data = utilities.replace_value_in_dict(self.user_data,
'password', 3)
self.assertRaises(TypeError, User, **invalid_data)
def test_email_is_right_format(self):
"""The email should be in the format [email protected]"""
invalid_data = utilities.replace_value_in_dict(self.user_data, 'email',
'hello')
self.assertRaises(ValueError, User, **invalid_data)
def test_email_is_string(self):
"""The email should be a string"""
invalid_data = utilities.replace_value_in_dict(self.user_data, 'email',
3)
self.assertRaises(TypeError, User, **invalid_data)
def test_last_name_is_string(self):
"""The last name should be a string"""
invalid_data = utilities.replace_value_in_dict(self.user_data,
'last_name', 3)
self.assertRaises(TypeError, User, **invalid_data)
