class TestDiet(unittest.TestCase):
"""
Tests for Diet.py
"""
@classmethod
def setUpClass(self):
"""
Set up the unit test.
"""
self.db = DB()
self.email = '*****@*****.**'
self.password = '******'
self.fullname = 'ABC'
self.user = User(self.db)
self.user.create_new_user(self.email, self.password, self.fullname)
self.user_id = self.user.check_email_match(self.email)
self.email_1 = '*****@*****.**'
self.password_1 = 'klmno'
self.fullname_1 = 'XYZ'
self.user_1 = User(self.db)
self.user_1.create_new_user(self.email_1, self.password_1,
self.fullname_1)
self.user_id_1 = self.user_1.check_email_match(self.email_1)
self.email_2 = '*****@*****.**'
self.password_2 = 'qqq'
self.fullname_2 = 'ASD'
self.user_2 = User(self.db)
self.user_2.create_new_user(self.email_2, self.password_2,
self.fullname_2)
self.user_id_2 = self.user_2.check_email_match(self.email_2)
self.diet = Diet(self.db, self.user_id)
self.diet_1 = Diet(self.db, self.user_id_1)
self.diet_2 = Diet(self.db, self.user_id_2)
self.diet_dict = {'Item': 'Apple',\
'ServingSize': 1.0,\
'Barcode': False,\
'nutri_dict': {'Cals': 100.0,'Protein': 100.0, 'Carbs': 100.0, 'Fat': 100.0, 'Fiber': 100.0}}
self.diet_dict_1 = {'Item': 'Orange',\
'ServingSize': 2.0,\
'Barcode': False,\
'nutri_dict': {'Cals': 105.0,'Protein': 105.0, 'Carbs': 105.0, 'Fat': 105.0, 'Fiber': 105.0}}
self.diet_dict_2 = {'Item': 'banana',\
'ServingSize': 2.0,\
'Barcode': False,\
'nutri_dict': {'Cals': 101.0,'Protein': 101.0, 'Carbs': 101.0, 'Fat': 101.0, 'Fiber': 101.0}}
self.dt1 = datetime.utcnow()
self.unix_time = round(time.time())
def test_0_data_insertion(self):
"""
Test database insertion for a single user.
"""
s = self.diet.insert_in_database(self.diet_dict, date_time=self.dt1)
self.assertEqual(s, True)
def test_1_data_insertion_multiple_users(self):
"""
Test database insertion for multiple users.
"""
s = self.diet.insert_in_database(self.diet_dict, date_time=self.dt1)
self.assertEqual(s, True)
s_1 = self.diet_1.insert_in_database(self.diet_dict_1,
date_time=self.dt1)
self.assertEqual(s_1, True)
s_2 = self.diet_2.insert_in_database(self.diet_dict_2)
self.assertEqual(s_2, True)
def test_2_incorrect_key(self):
"""
Test for incorrect keys. The function should return False if the input dictionary keys are incorrect.
"""
d = copy.deepcopy(self.diet_dict)
del (d['Item'])
d['ItemS'] = 'Apple'
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
del (d['ServingSize'])
d['ServinsSizeS'] = 1.0
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
del (d['Barcode'])
d['BarcodeS'] = False
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
del (d['nutri_dict'])
d['nutri_dictS'] = {
'Cals': 100.0,
'Protein': 100.0,
'Carbs': 100.0,
'Fat': 100.0,
'Fiber': 100.0
}
self.assertFalse(self.diet.insert_in_database(d))
def test_3_incorrect_key_1(self):
"""
Test for incorrect keys in the nutri_dict. The function should return False if the nutrient names is incorrect.
"""
d = copy.deepcopy(self.diet_dict)
del (d['nutri_dict']['Cals'])
d['nutri_dict']['CalsS'] = 100.0
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
del (d['nutri_dict']['Protein'])
d['nutri_dict']['ProteinS'] = 100.0
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
del (d['nutri_dict']['Carbs'])
d['nutri_dict']['CarbS'] = 100.0
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
del (d['nutri_dict']['Fat'])
d['nutri_dict']['FatS'] = 100.0
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
del (d['nutri_dict']['Fiber'])
d['nutri_dict']['FiberS'] = 100.0
self.assertFalse(self.diet.insert_in_database(d))
def test_4_incorrect_value(self):
"""
Test for incorrect value data type.
"""
d = copy.deepcopy(self.diet_dict)
d['Item'] = 1
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
d['ServingSize'] = 'Apple'
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
d['Barcode'] = 1
self.assertFalse(self.diet.insert_in_database(d))
def test_5_incorrect_value_1(self):
"""
Test for incorrect value data type in the nutrients dictionary.
"""
d = copy.deepcopy(self.diet_dict)
d['nutri_dict']['Cals'] = 'Apple'
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
d['nutri_dict']['Protein'] = 'Apple'
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
d['nutri_dict']['Fiber'] = 'Apple'
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
d['nutri_dict']['Carbs'] = 'Apple'
self.assertFalse(self.diet.insert_in_database(d))
d = copy.deepcopy(self.diet_dict)
d['nutri_dict']['Fat'] = 'Apple'
self.assertFalse(self.diet.insert_in_database(d))
def test_6_data_fetching_unix_time_and_insertion(self):
"""
Test fetching diet data from database and also checks if the UNIX TIMESTAMP is correct.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.diet.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(result[0]['Datetime'], self.unix_time)
def test_7_data_fetching_values(self):
"""
Test fetching diet data from database for multiple users.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.diet.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(result[0]['Item'], 'Apple')
self.assertEqual(result[0]['ServingSize'], 1.0)
self.assertEqual(result[0]['Cals'], 100.0)
self.assertEqual(result[0]['Fiber'], 100.0)
self.assertEqual(result[0]['Carbs'], 100.0)
self.assertEqual(result[0]['Fat'], 100.0)
self.assertEqual(result[0]['Protein'], 100.0)
self.assertFalse(result[0]['Barcode'])
result_1, success_1 = self.diet_1.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success_1)
self.assertEqual(result_1[0]['Item'], 'Orange')
self.assertEqual(result_1[0]['ServingSize'], 2.0)
self.assertEqual(result_1[0]['Cals'], 105.0)
self.assertEqual(result_1[0]['Fiber'], 105.0)
self.assertEqual(result_1[0]['Carbs'], 105.0)
self.assertEqual(result_1[0]['Fat'], 105.0)
self.assertEqual(result_1[0]['Protein'], 105.0)
self.assertFalse(result_1[0]['Barcode'])
def test_8_incorrect_data_fetching(self):
"""
Test fetching diet data from the database for incorrect date range. The function
should return False.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.diet.get_columns_given_range(
dt1 + timedelta(days=10), dt1 + timedelta(days=11))
self.assertFalse(success)
def test_9_data_fetching_multiple(self):
"""
Test fetching multiple diet entries from the database.
"""
d = {'Item': 'Apple',\
'ServingSize': 1.0,\
'Barcode': False,\
'nutri_dict': {'Cals': 100.0,'Protein': 100.0, 'Carbs': 100.0, 'Fat': 100.0, 'Fiber': 100.0}}
_ = self.diet.insert_in_database(d,
date_time=datetime.utcnow() +
timedelta(days=1) +
timedelta(minutes=1))
d = {'Item': 'Orange',\
'ServingSize': 1.0,\
'Barcode': False,\
'nutri_dict': {'Cals': 100.0,'Protein': 100.0, 'Carbs': 100.0, 'Fat': 100.0, 'Fiber': 100.0}}
_ = self.diet.insert_in_database(d,
date_time=datetime.utcnow() +
timedelta(days=1) +
timedelta(minutes=2))
d = {'Item': 'Banana',\
'ServingSize': 1.0,\
'Barcode': False,\
'nutri_dict': {'Cals': 100.0,'Protein': 100.0, 'Carbs': 100.0, 'Fat': 100.0, 'Fiber': 100.0}}
_ = self.diet.insert_in_database(d,
date_time=datetime.utcnow() +
timedelta(days=1) +
timedelta(minutes=3))
d1 = date.today() + timedelta(days=1)
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.diet.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(len(result), 3)
self.assertEqual(result[0]['Item'], 'Apple')
self.assertEqual(result[1]['Item'], 'Orange')
self.assertEqual(result[2]['Item'], 'Banana')
def test_10_incorrect_database(self):
"""
Test database insertion for a single user with incorrect database. Test case to increase the coverage.
"""
diet = Diet(None, self.user_id_2)
s = diet.insert_in_database(self.diet_dict, date_time=self.dt1)
self.assertFalse(s)
d1 = date.today() + timedelta(days=1)
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = diet.get_columns_given_range(dt1,
dt1 + timedelta(days=1))
self.assertFalse(success)
class TestFitness(unittest.TestCase):
"""
Tests for Fitness.py
"""
@classmethod
def setUpClass(self):
"""
Set up the unit test.
"""
self.db = DB()
self.email = '*****@*****.**'
self.password = '******'
self.fullname = 'ABC'
self.user = User(self.db)
self.user.create_new_user(self.email, self.password, self.fullname)
self.user_id = self.user.check_email_match(self.email)
self.email_1 = '*****@*****.**'
self.password_1 = 'klmno'
self.fullname_1 = 'XYZ'
self.user_1 = User(self.db)
self.user_1.create_new_user(self.email_1, self.password_1,
self.fullname_1)
self.user_id_1 = self.user_1.check_email_match(self.email_1)
self.fitness = Fitness(self.db, self.user_id)
self.fitness_dict = {'WorkoutType': 'Running',\
'Minutes': 10.0,\
'CaloriesBurned': 100.9}
self.fitness_1 = Fitness(self.db, self.user_id_1)
self.fitness_dict_1 = {'WorkoutType': 'Sleeping',\
'Minutes': 100.0,\
'CaloriesBurned': 10.9}
self.dt1 = datetime.utcnow()
self.unix_time = round(time.time())
def test_0_data_insertion(self):
"""
Test database insertion for a single user.
"""
s = self.fitness.insert_in_database(self.fitness_dict,
date_time=self.dt1)
self.assertTrue(s)
def test_1_data_insertion_multiple_users(self):
"""
Test database insertion for multiple users.
"""
s = self.fitness.insert_in_database(self.fitness_dict,
date_time=self.dt1)
self.assertEqual(s, True)
s_1 = self.fitness_1.insert_in_database(self.fitness_dict_1,
date_time=self.dt1)
self.assertEqual(s_1, True)
def test_2_incorrect_key(self):
"""
Test for incorrect keys. The input keys are the columns of the fitness table.
"""
d = copy.deepcopy(self.fitness_dict)
del (d['WorkoutType'])
d['WorkoutTypeS'] = 'Running'
self.assertFalse(self.fitness.insert_in_database(d))
d = copy.deepcopy(self.fitness_dict)
del (d['Minutes'])
d['MinutesS'] = 10.0
self.assertFalse(self.fitness.insert_in_database(d))
d = copy.deepcopy(self.fitness_dict)
del (d['CaloriesBurned'])
d['CaloriesBurnedS'] = 100.9
self.assertFalse(self.fitness.insert_in_database(d))
def test_3_incorrect_value(self):
"""
Test for incorrect value data type before inserting in the fitness database.
"""
d = copy.deepcopy(self.fitness_dict)
d['WorkoutType'] = 1
self.assertFalse(self.fitness.insert_in_database(d))
d = copy.deepcopy(self.fitness_dict)
d['Minutes'] = 'Running'
self.assertFalse(self.fitness.insert_in_database(d))
d = copy.deepcopy(self.fitness_dict)
d['CaloriesBurned'] = 1
self.assertFalse(self.fitness.insert_in_database(d))
def test_4_data_fetching_unix_time_and_insertion(self):
"""
Test fetching fitness data from database and also check if the UNIX TIMESTAMP is correct.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.fitness.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(result[0]['Datetime'], self.unix_time)
def test_6_data_fetching_values_multiple_users(self):
"""
Test fetching fitness data from database for multiple users.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.fitness.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(result[0]['WorkoutType'], 'Running')
self.assertEqual(result[0]['Minutes'], 10.0)
self.assertEqual(result[0]['CaloriesBurned'], 100.9)
result_1, success_1 = self.fitness_1.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success_1)
self.assertEqual(result_1[0]['WorkoutType'], 'Sleeping')
self.assertEqual(result_1[0]['Minutes'], 100.0)
self.assertEqual(result_1[0]['CaloriesBurned'], 10.9)
def test_7_incorrect_data_fetching(self):
"""
Test fetching fitness from the database for incorrect date range. The function should return False.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.fitness.get_columns_given_range(
dt1 + timedelta(days=10), dt1 + timedelta(days=11))
self.assertFalse(success)
def test_8_data_fetching_multiple(self):
"""
Test fetching multiple fitness data entries from the database.
"""
d = {'WorkoutType': 'Running',\
'Minutes': 10.0,\
'CaloriesBurned': 100.9}
_ = self.fitness.insert_in_database(d,
date_time=datetime.utcnow() +
timedelta(days=1) +
timedelta(minutes=1))
d = {'WorkoutType': 'Jogging',\
'Minutes': 10.0,\
'CaloriesBurned': 100.9}
_ = self.fitness.insert_in_database(d,
date_time=datetime.utcnow() +
timedelta(days=1) +
timedelta(minutes=2))
d = {'WorkoutType': 'Dancing',\
'Minutes': 10.0,\
'CaloriesBurned': 100.9}
_ = self.fitness.insert_in_database(d,
date_time=datetime.utcnow() +
timedelta(days=1) +
timedelta(minutes=4))
d1 = date.today() + timedelta(days=1)
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.fitness.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertEqual(len(result), 3)
self.assertTrue(success)
self.assertEqual(result[0]['WorkoutType'], 'Running')
self.assertEqual(result[1]['WorkoutType'], 'Jogging')
self.assertEqual(result[2]['WorkoutType'], 'Dancing')
def test_9_incorrect_database(self):
"""
Test database insertion for a single user with incorrect database. Test case to increase the coverage.
"""
fitness = Fitness(None, self.user_id_1)
s = fitness.insert_in_database(self.fitness_dict, date_time=self.dt1)
self.assertFalse(s)
class TestSleep(unittest.TestCase):
"""
Tests for Sleep.py
"""
@classmethod
def setUpClass(self):
"""
Set up the unittest.
"""
self.db = DB()
self.email = '*****@*****.**'
self.password = '******'
self.fullname = 'ABC'
self.user = User(self.db)
self.user.create_new_user(self.email, self.password, self.fullname)
self.user_id = self.user.check_email_match(self.email)
self.email_1 = '*****@*****.**'
self.password_1 = 'klmno'
self.fullname_1 = 'XYZ'
self.user_1 = User(self.db)
self.user_1.create_new_user(self.email_1, self.password_1,
self.fullname_1)
self.user_id_1 = self.user_1.check_email_match(self.email_1)
self.sleep = Sleep(self.db, self.user_id)
self.sleep_1 = Sleep(self.db, self.user_id_1)
self.sleep_time = datetime.utcnow()
self.wakeup_time = datetime.utcnow() + timedelta(minutes=1)
self.sleep_dict = {'Nap': False,\
'SleepTime': self.sleep_time,\
'WakeupTime': self.wakeup_time}
self.sleep_time_1 = datetime.utcnow()
self.wakeup_time_1 = datetime.utcnow() + timedelta(minutes=2)
self.sleep_dict_1 = {'Nap': False,\
'SleepTime': self.sleep_time_1,\
'WakeupTime': self.wakeup_time_1}
self.dt1 = datetime.utcnow()
self.unix_time = round(time.time())
def test_0_data_insertion(self):
"""
Test data insertion for sleep for a single user.
"""
s = self.sleep.insert_in_database(self.sleep_dict, date_time=self.dt1)
self.assertTrue(s)
def test_1_data_insertion_multiple_user(self):
"""
Test data insertion for sleep for multiple users.
"""
s = self.sleep.insert_in_database(self.sleep_dict, date_time=self.dt1)
self.assertTrue(s)
s_1 = self.sleep_1.insert_in_database(self.sleep_dict_1,
date_time=self.dt1)
self.assertTrue(s_1)
def test_2_incorrect_key(self):
"""
Test for incorrect keys.
"""
d = copy.deepcopy(self.sleep_dict)
del (d['Nap'])
d['NapS'] = False
self.assertFalse(self.sleep.insert_in_database(d))
d = copy.deepcopy(self.sleep_dict)
del (d['SleepTime'])
d['SleepTimeS'] = datetime.utcnow()
self.assertFalse(self.sleep.insert_in_database(d))
d = copy.deepcopy(self.sleep_dict)
del (d['WakeupTime'])
d['WakeupTimeS'] = datetime.utcnow()
self.assertFalse(self.sleep.insert_in_database(d))
def test_3_incorrect_value(self):
"""
Test for incorrect value data type.
"""
d = copy.deepcopy(self.sleep_dict)
d['Nap'] = 10
self.assertFalse(self.sleep.insert_in_database(d))
d = copy.deepcopy(self.sleep_dict)
d['SleepTime'] = 10
self.assertFalse(self.sleep.insert_in_database(d))
d = copy.deepcopy(self.sleep_dict)
d['WakeupTime'] = 10
self.assertFalse(self.sleep.insert_in_database(d))
def test_4_data_fetching_unix_time_and_insertion(self):
"""
Test fetching sleep data from database and the UNIX TIMESTAMP.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.sleep.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(result[0]['Datetime'], self.unix_time)
def test_5_data_fetching_value(self):
"""
Test fetching sleep data from database for multiple users.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.sleep.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(
result[0]['SleepTime'],
round(self.sleep_time.replace(tzinfo=timezone.utc).timestamp()))
self.assertEqual(
result[0]['WakeupTime'],
round(self.wakeup_time.replace(tzinfo=timezone.utc).timestamp()))
self.assertFalse(result[0]['Nap'])
self.assertEqual(result[0]['Minutes'], 1)
result_1, success_1 = self.sleep_1.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success_1)
self.assertEqual(
result_1[0]['SleepTime'],
round(self.sleep_time_1.replace(tzinfo=timezone.utc).timestamp()))
self.assertEqual(
result_1[0]['WakeupTime'],
round(self.wakeup_time_1.replace(tzinfo=timezone.utc).timestamp()))
self.assertFalse(result_1[0]['Nap'])
self.assertEqual(result_1[0]['Minutes'], 2)
sleep = Sleep(None, self.user_id_1)
result, success = sleep.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertFalse(success)
def test_6_minutes_computation(self):
"""
Test the minute computation in sleep.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.sleep.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(result[0]['Minutes'], 1)
def test_7_incorrect_data_fetching(self):
"""
Test fetching sleep data from database.
"""
d1 = date.today()
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.sleep.get_columns_given_range(
dt1 + timedelta(days=10), dt1 + timedelta(days=11))
self.assertFalse(success)
def test_8_data_fetching_multiple(self):
"""
Test fetching of multiple sleep entries from database.
"""
d = {
'Nap': False,\
'SleepTime': datetime.utcnow() + timedelta(days=1),\
'WakeupTime': datetime.utcnow() + timedelta(days=1) + timedelta(minutes=1)}
_ = self.sleep.insert_in_database(d)
d = {
'Nap': False,\
'SleepTime': datetime.utcnow() + timedelta(days=1),\
'WakeupTime': datetime.utcnow() + timedelta(days=1) + timedelta(minutes=2)}
_ = self.sleep.insert_in_database(d)
d = {
'Nap': False,\
'SleepTime': datetime.utcnow() + timedelta(days=1),\
'WakeupTime': datetime.utcnow() + timedelta(days=1) + timedelta(minutes=3)}
_ = self.sleep.insert_in_database(d)
d1 = date.today() + timedelta(days=1)
dt1 = datetime(d1.year, d1.month, d1.day) + timedelta(hours=8)
result, success = self.sleep.get_columns_given_range(
dt1, dt1 + timedelta(days=1))
self.assertTrue(success)
self.assertEqual(len(result), 3)
self.assertEqual(result[0]['Minutes'], 1)
self.assertEqual(result[1]['Minutes'], 2)
self.assertEqual(result[2]['Minutes'], 3)
def test_9_incorrect_database(self):
"""
Test database insertion for a single user with incorrect database. Test case to increase the coverage.
"""
sleep = Sleep(None, self.user_id_1)
s = sleep.insert_in_database(self.sleep_dict, date_time=self.dt1)
self.assertFalse(s)
class TestUser(unittest.TestCase):
"""
Tests for user.py
"""
@classmethod
def setUpClass(self):
"""
Set up the unit test.
"""
self.db = DB()
self.email = '*****@*****.**'
self.password = '******'
self.fullname = 'ABC'
self.user = User(self.db)
self.user.create_new_user(self.email, self.password, self.fullname)
self.user_id = self.user.check_email_match(self.email)
def test_create_new_user(self):
"""
Test inserting an input in the database
"""
email = f'{get_random_string(4)}@gmail.com'
password = '******'
fullname = 'ABCD'
self.assertTrue(self.user.create_new_user(email,password,fullname))
def test_user_already_exists(self):
"""
Test inserting an input in the database
"""
email = '*****@*****.**'
password = '******'
fullname = 'ABCD'
self.assertFalse(self.user.create_new_user(email,password,fullname))
def test_email_match(self):
"""
Test inserting an input in the database
"""
email = '*****@*****.**'
password = '******'
self.assertTrue(isinstance(self.user.check_email_match(email),int))
def test_incorrect_email_match(self):
"""
Test inserting an input in the database
"""
email = '*****@*****.**'
password = '******'
self.assertEqual(self.user.check_email_match(email),-1)
def test_password_match(self):
"""
Test inserting an input in the database
"""
email = '*****@*****.**'
password = '******'
self.assertTrue(isinstance(self.user.check_password_match(email,password),int))
user = User(None)
email = '*****@*****.**'
password = '******'
self.assertEqual(self.user.check_password_match(None,None),-1)
def test_incorrect_password_match(self):
"""
Test inserting an input in the database
"""
email = '*****@*****.**'
password = '******'
self.assertEqual(self.user.check_password_match(email,password),-1)
def test_token(self):
"""
Test the encoding and decoding token functions.
"""
num = 10
token, code = self.user.encode_token(num)
dec_num, dec_code = self.user.decode_token(token)
self.assertEqual(num, dec_num)
class TestGoals(unittest.TestCase):
"""
Test for goals.py
"""
@classmethod
def setUpClass(self):
"""
Set up the unit test.
"""
self.db = DB()
self.email = '*****@*****.**'
self.password = '******'
self.fullname = 'ABCD'
self.user = User(self.db)
self.user.create_new_user(self.email, self.password, self.fullname)
self.user_id = self.user.check_email_match(self.email)
self.goals = Goals(self.db, self.user_id)
self.diet_goal_dict = {'Type': 'Calories', 'Value': 1000.0}
self.fitness_goal_dict = {'Type': 'FitnessMinutes', 'Value': 100.0}
self.sleep_goal_dict = {'Type': 'SleepHours', 'Value': 10.0}
self.goals.set_goal(self.diet_goal_dict)
self.goals.set_goal(self.fitness_goal_dict)
self.goals.set_goal(self.sleep_goal_dict)
def test_alter_goal(self):
"""
Test altering a goal. Change all the goals and check for correctness.
"""
self.assertTrue(self.goals.alter_goal('Calories', 99.0))
self.assertTrue(self.goals.alter_goal('FitnessMinutes', 50.0))
self.assertTrue(self.goals.alter_goal('SleepHours', 1.99))
goal, status = self.goals.get_latest_goal(Type='Calories')
self.assertEqual(goal[0]['Value'], 99.0)
goal, status = self.goals.get_latest_goal(Type='FitnessMinutes')
self.assertEqual(goal[0]['Value'], 50.0)
goal, status = self.goals.get_latest_goal(Type='SleepHours')
self.assertEqual(goal[0]['Value'], 1.99)
goals = Goals(None, self.user_id)
self.assertFalse(goals.alter_goal('Calories', 99.0))
def test_incorrect_alter_type_goal(self):
"""
Test for incorrect alter type. The function alter_goal() should return False.
"""
self.assertFalse(self.goals.alter_goal('CaloriesS', 99.0))
self.assertFalse(self.goals.alter_goal('FitnessMinutesS', 50.0))
self.assertFalse(self.goals.alter_goal('SleepHoursS', 1.99))
def test_incorrect_alter_value_type_goal(self):
"""
Test for incorrect alter value data type.
"""
self.assertFalse(self.goals.alter_goal('Calories', 'A'))
self.assertFalse(self.goals.alter_goal('FitnessMinutes', 50))
self.assertFalse(self.goals.alter_goal('SleepHours', 'B'))
def test_get_latest_goal(self):
"""
Test getting the latest goal of a particular type, Diet, Fitness or Sleep.
"""
goal, status = self.goals.get_latest_goal(Type='Calories')
self.assertTrue(status)
goal, status = self.goals.get_latest_goal(Type='FitnessMinutes')
self.assertTrue(status)
goal, status = self.goals.get_latest_goal(Type='SleepHours')
self.assertTrue(status)
goals = Goals(None, self.user_id)
goal, status = goals.get_latest_goal(Type='Calories')
self.assertFalse(status)
def test_incorrect_get_latest_goal(self):
"""
Test incorrect goal type while getting the latest goal of a particular type.
"""
goal, status = self.goals.get_latest_goal(Type='A')
self.assertFalse(status)
def test_get_all_goals(self):
"""
Test getting all the goals from the table.
"""
goals, status = self.goals.get_all_goals()
self.assertTrue(status)
goals = Goals(None, self.user_id)
goal, status = goals.get_all_goals()
self.assertFalse(status)
def test_get_type_goals(self):
"""
Test getting all the goals of a particular type. Mostly we will only be interested in the latest goal.
"""
goal, status = self.goals.get_type_goals('Calories')
self.assertTrue(status)
goals = Goals(None, self.user_id)
goal, status = goals.get_type_goals('Calories')
self.assertFalse(status)
def test_incorrect_get_type_goals(self):
"""
Test for incorrect goal type while getting all the goals of a particular type. Mostly we will only be interested in the latest goal.
"""
goal, status = self.goals.get_type_goals('A')
self.assertFalse(status)
def test_set_goal(self):
"""
Test setting a goal. Set all the three goals, Diet, Fitness and Sleep.
"""
self.assertTrue(self.goals.set_goal(self.diet_goal_dict))
self.assertTrue(self.goals.set_goal(self.fitness_goal_dict))
self.assertTrue(self.goals.set_goal(self.sleep_goal_dict))
goals = Goals(None, self.user_id)
self.assertFalse(goals.set_goal(self.diet_goal_dict))
def test_incorrect_key_set_goal(self):
"""
Test for incorrect keys. We send incorrect keys: Typo and Valuo. These keys are the columns in our tables.
"""
d = {'Typo': 'Calories', 'Valuo': 100.0}
self.assertFalse(self.goals.set_goal(d))
def test_incorrect_value_type_set_goal(self):
"""
Test for incorrect value data types. We use int for the Value instead of float (in python) and double (in mysql).
"""
d = {'Type': 'Calories', 'Value': 100}
self.assertFalse(self.goals.set_goal(d))
