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)