class DatabaseTest(unittest.TestCase):
def setUp(self):
self.db=Database()
self.user_data={
'first_name':'Wamula',
'last_name':'Bashir',
'email':'*****@*****.**',
'password':'******',
}
self.user =User(**self.user_data,key=1)
self.category_data={
'key':1,
'name':'hello',
'description':'hello world',
'user':self.user.key,
}
def test_get_next_key(self):
self.assertEqual(self.db.get_next_key(User),1)
self.db._user_keys +=[1,2,3]
self.assertEqual(self.db.get_next_key(User),4)
self.assertRaises(TypeError, self.db.get_next_key,2)
class DatabaseTest(unittest.TestCase):
"""
Tests for the Database class
"""
def setUp(self):
"""Declares variables to be used in most tests"""
self.db = Database()
self.user_data = {
'first_name': 'John',
'last_name': 'Doe',
'email': '*****@*****.**',
'password': '******',
}
self.user = User(**self.user_data, key=1)
self.category_data = {
'key': 1,
'name': 'cakes',
'description': 'all orders cake!',
'user': self.user.key,
}
self.order_data = {
'key': 1,
'name': 'breadcake',
'description': 'yummy',
'category': self.category_data['key'],
}
self.order_step_data = {
'key': 1,
'text_content': "Don't do anything",
'order': self.order_data['key'],
}
def test_get_next_key(self):
"""The next key for each model object type can be got"""
self.assertEqual(self.db.get_next_key(User), 1)
self.assertEqual(self.db.get_next_key(order), 1)
self.assertEqual(self.db.get_next_key(orderCategory), 1)
self.assertEqual(self.db.get_next_key(orderStep), 1)
self.db._user_keys += [1, 2, 3]
self.assertEqual(self.db.get_next_key(User), 4)
self.db._order_keys += [1, 2, 3, 7]
self.assertEqual(self.db.get_next_key(order), 8)
self.db._order_category_keys += [1, 2, 3, 4]
self.assertEqual(self.db.get_next_key(orderCategory), 5)
self.db._order_step_keys += [1, 2, 3, 9]
self.assertEqual(self.db.get_next_key(orderStep), 10)
self.assertRaises(TypeError, self.db.get_next_key, 2)
def test_create_user(self):
"""A user can be created in 'Database'"""
user = self.db.create_user(self.user_data)
self.assertIsInstance(user, User)
self.assertIn(user.key, self.db.user_keys)
self.assertEqual(user, self.db.users[user.key])
self.assertIn(user.email, self.db.user_email_key_map.keys())
self.assertEqual(user.key, self.db.user_email_key_map[user.email])
def test_get_user(self):
"""A user can be got by user_key"""
user = User(**self.user_data, key=1)
user.save(self.db)
user_from_db = self.db.get_user(user.key)
self.assertEqual(user, user_from_db)
non_existent_key = 3
self.assertIsNone(self.db.get_user(non_existent_key))
self.assertRaises(TypeError, self.db.get_user,
'user_key should be int')
def test_get_user_by_email(self):
"""A user can be got by email"""
user = self.db.create_user(self.user_data)
self.assertIsInstance(user, User)
user_instance = self.db.get_user_by_email(user.email)
self.assertEqual(user, user_instance)
self.assertRaises(TypeError, self.db.get_user_by_email, 2)
def test_get_order_category(self):
"""A order category can be retrieved by key"""
# setup
self.user.save(self.db)
# create category
category = orderCategory(**self.category_data)
# save category
category.save(self.db)
# try retrieving the category
category_from_db = self.db.get_order_category(category.key)
self.assertEqual(category, category_from_db)
# try retrieving a non-existent category
self.assertIsNone(self.db.get_order_category(4))
# try using a non-int key
self.assertRaises(TypeError, self.db.get_order_category,
'string instead of int')
def test_delete_object_for_category(self):
"""delete_object should be able to remove the object passed to it from the database"""
# setup
self.user.save(self.db)
# create category
category = orderCategory(**self.category_data)
# save category
category.save(self.db)
# create order
order = order(**self.order_data)
# save order as child of category due to key set in setUp
order.save(self.db)
# delete category
##################Test deleting categories####################
self.db.delete_object(category)
# assert that the category object is not in self.db.order_categories
self.assertRaises(KeyError, utilities.return_value_from_dict,
self.db.order_categories, category.key)
# assert that the order object is not in self.db.orders
self.assertRaises(KeyError, utilities.return_value_from_dict,
self.db.orders, order.key)
# assert that the category key is not in self.db.order_category_keys
self.assertNotIn(category.key, self.db.order_category_keys)
# assert that the order key is not in self.db.order_keys
self.assertNotIn(order.key, self.db.order_keys)
# assert that the category name is not in self.db.order_categories_name_key_map
self.assertNotIn(category.name,
self.db.order_category_name_key_map.keys())
# assert that the order name is not in self.db.order_name_key_map
self.assertNotIn(order.name, self.db.order_name_key_map.keys())
# try to delete a non existent object by deleting category again
self.assertRaises(KeyError, self.db.delete_object, category)
# try to delete an object of a type that does not exist in database
self.assertRaises(TypeError, self.db.delete_object, 2)
def test_delete_object_for_orders(self):
"""delete_object should be able to remove the object passed to it from the database"""
# setup
self.user.save(self.db)
category = orderCategory(**self.category_data)
category.save(self.db)
order = order(**self.order_data)
order.save(self.db)
# create step as child of order
order_step = orderStep(**self.order_step_data)
order_step.save(self.db)
# delete order
self.db.delete_object(order)
# assert that the order step object is not in self.db.order_steps
self.assertRaises(KeyError, utilities.return_value_from_dict,
self.db.order_steps, order_step.key)
# assert that the order object is not in self.db.orders
self.assertRaises(KeyError, utilities.return_value_from_dict,
self.db.orders, order.key)
# assert that the order step key is not in self.db.order_step_keys
self.assertNotIn(order_step.key, self.db.order_step_keys)
# assert that the order key is not in self.db.order_keys
self.assertNotIn(order.key, self.db.order_keys)
# assert that the order name is not in self.db.order_name_key_map
self.assertNotIn(order.name, self.db.order_name_key_map.keys())
# try to delete a non existent object by deleting category again
self.assertRaises(KeyError, self.db.delete_object, order)
def test_get_order(self):
"""A order can be retrieved by key"""
# setup
self.user.save(self.db)
category = orderCategory(**self.category_data)
category.save(self.db)
order = order(**self.order_data)
order.save(self.db)
# try retrieving the order
order_from_db = self.db.get_order(order.key)
self.assertEqual(order, order_from_db)
# try retrieving a non-existent order
self.assertIsNone(self.db.get_order(4))
# try using a non-int key
self.assertRaises(TypeError, self.db.get_order,
'string instead of int')
def test_get_order_step(self):
"""A order step can be retrieved by key"""
# setup
self.user.save(self.db)
category = orderCategory(**self.category_data)
category.save(self.db)
order = order(**self.order_data)
order.save(self.db)
order_step = orderStep(**self.order_step_data)
order_step.save(self.db)
# try retrieving the order step
order_step_from_db = self.db.get_order_step(order_step.key)
self.assertEqual(order_step, order_step_from_db)
# try retrieving a non-existent order step
self.assertIsNone(self.db.get_order_step(50))
# try using a non-int key
self.assertRaises(TypeError, self.db.get_order_step,
'string instead of int')