def test_attribute_types(self):
"""
tests the class attributes exist and are of correct type
also tests instantiation of new object
"""
# creates new instance of Skills
new_obj = Skills()
# adds name attribute (inherited requirement from BaseModel)
# adds optional attributes for testing
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj.name = "test_name"
# attributes_dict sets up dictionary of attribute names and types
attributes_dict = {
"id": str,
"created_at": datetime,
"updated_at": datetime,
"name": str,
}
# loops through attributes_dict as subTests to check each attribute
for attr, attr_type in attributes_dict.items():
with self.subTest(attr=attr, attr_type=attr_type):
# tests the expected attribute is in the instance's dict
self.assertIn(attr, new_obj.__dict__)
# tests the attribute is the expected type
self.assertIs(type(new_obj.__dict__[attr]), attr_type)
def post(self):
if self.user:
name = self.request.get('skill_name')
if name:
s = Skills(parent=skills_key(), name=name, user=self.user)
s.put()
self.redirect('/main')
else:
self.render('errorpage.html', error="No Skill Given")
else:
self.redirect('/login')
def test_save_method(self, mock_storage):
"""
tests that the save() method inherited from BaseModel calls on
storage.new() to add and commit the object to the database
"""
# creates new instance of Skills
new_obj = Skills()
# adds name as required attribute for database
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj.name = "test_name"
# saves new instance and tests if storage method new is called
new_obj.save()
self.assertTrue(mock_storage.new.called)
def get(self):
if self.user:
# skills
skills = Skills.query(Skills.user == self.user).fetch()
# recent projects
recent = Projects.query(Projects.user == self.user).fetch(limit=5)
# create dictionary to hold categories with their projects
data = {}
# holds the categories which are meant to be shown on homepage
featured_categories = []
categories = Categories.query(Categories.user == self.user).fetch()
for i in categories:
if (i.feature == True):
featured_categories.append(i)
data['{}'.format(i.name)] = Projects.query(
Projects.category_name == i.name
and Projects.feature == True
and Projects.user == self.user).fetch()
self.render('welcome.html',
recent=recent,
data=data,
categories=featured_categories,
skills=skills,
user=self.user)
else:
self.redirect('/login')
def create_skills():
"""
create a new instance of Skills
through POST request
"""
# get JSON from POST request
json = request.get_json(silent=True)
# checks for missing attributes
if json is None:
abort(400, 'Not a JSON')
if 'name' not in json:
abort(400, 'Missing name attribute')
# create new instance with **kwargs from json
new_obj = Skills(**json)
new_obj.save()
# return json version of object's to_dict()
return jsonify(new_obj.to_dict()), 201
def get(self):
projects = Projects.query(Projects.user == self.user).fetch()
categories = Categories.query(Categories.user == self.user).fetch()
skills = Skills.query(Skills.user == self.user).fetch()
self.render('projects.html',
projects=projects,
categories=categories,
skills=skills)
def test_init_method(self):
"""
tests the __init__ method for instantiating new objects
both new and from kwargs
__init__ method calls on inherited BaseModel with super()
"""
# creates new instance of Skills
new_obj1 = Skills()
# tests that the new object is of type Skills
self.assertIs(type(new_obj1), Skills)
# adds all attributes for testing
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj1.name = "test_name"
# attributes_dict sets up dictionary of attribute names and types
attributes_dict = {
"id": str,
"created_at": datetime,
"updated_at": datetime,
"name": str,
}
# loops through attributes_dict as subTests to check each attribute
for attr, attr_type in attributes_dict.items():
with self.subTest(attr=attr, attr_type=attr_type):
# tests the expected attribute is in the object's dict
self.assertIn(attr, new_obj1.__dict__)
# tests the attribute is the expected type
self.assertIs(type(new_obj1.__dict__[attr]), attr_type)
# sets kwargs using object's dict and uses to create new object
kwargs = new_obj1.__dict__
new_obj2 = Skills(**kwargs)
# tests that the new object is of type Skills
self.assertIs(type(new_obj2), Skills)
# loops through attributes_dict as subTests to check each attribute
for attr, attr_type in attributes_dict.items():
with self.subTest(attr=attr, attr_type=attr_type):
# tests the expected attribute is in the object's dict
self.assertIn(attr, new_obj2.__dict__)
# tests the attribute is the expected type
self.assertIs(type(new_obj2.__dict__[attr]), attr_type)
# tests the value of name attribute matches the original object
self.assertEqual(new_obj1.__dict__[attr],
new_obj2.__dict__[attr])
# tests that __class__ is not set in object 2
self.assertNotIn('__class__', new_obj2.__dict__)
def test_class_and_subclass(self):
"""
tests that instances are of Skills class
and are a subclass of BaseModel class
"""
new_obj = Skills()
# tests that the new instance is of type Skills
self.assertIs(type(new_obj), Skills)
# tests that the new instance is a subclass of BaseModel
self.assertIsInstance(new_obj, BaseModel)
def test_str_method(self):
"""
tests the __str__ method returns the correct format
this method is inherited from BaseModel, but should show Skills class
"""
# creates new instance of Skills and saves variables
new_obj = Skills()
obj_id = new_obj.id
obj_dict = new_obj.__dict__
# tests the string representation of object is formatted correctly
self.assertEqual(str(new_obj),
"[Skills.{}] {}".format(obj_id, obj_dict))
def test_delete_skills(self):
"""
tests the storage.delete() method removes and commits obj to database
for an object from the Skills class
"""
# connect to MySQL database through MySQLdb and get initial count
db = connect(host=ION_MYSQL_HOST,
user=ION_MYSQL_USER,
passwd=ION_MYSQL_PWD,
db=ION_MYSQL_DB)
cur = db.cursor()
cur.execute("""SELECT * FROM skills""")
objs_for_count1 = cur.fetchall()
# creates new instance of Skills
new_obj = Skills()
# tests that the new object is of type Skills
self.assertIs(type(new_obj), Skills)
# adds all attributes required for testing
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj.name = "test_name"
# save the object with BaseModel save method
# save method calls storage.new() and storage.save()
new_obj.save()
# closes connection to database and restarts connection with MySQLdb
cur.close()
db.close()
db = connect(host=ION_MYSQL_HOST,
user=ION_MYSQL_USER,
passwd=ION_MYSQL_PWD,
db=ION_MYSQL_DB)
cur = db.cursor()
cur.execute("""SELECT * FROM skills""")
objs_for_count2 = cur.fetchall()
# tests that there is one more obj saved to skills table in db
self.assertEqual(len(objs_for_count1) + 1, len(objs_for_count2))
# delete the object with BaseModel delete method
# delete instance method calls storage.delete() and storage.save()
new_obj.delete()
# closes connection to database and restarts connection with MySQLdb
cur.close()
db.close()
db = connect(host=ION_MYSQL_HOST,
user=ION_MYSQL_USER,
passwd=ION_MYSQL_PWD,
db=ION_MYSQL_DB)
cur = db.cursor()
cur.execute("""SELECT * FROM skills""")
objs_for_count3 = cur.fetchall()
# tests that there is one less obj in skills table in db
self.assertEqual(len(objs_for_count2) - 1, len(objs_for_count3))
self.assertEqual(len(objs_for_count1), len(objs_for_count3))
# closes the connection
cur.close()
db.close()
def test_all_skills_count(self):
"""
tests all method retrieves all objects when class is Skills
"""
# connect to MySQL database through MySQLdb and get initial count
db = connect(host=ION_MYSQL_HOST,
user=ION_MYSQL_USER,
passwd=ION_MYSQL_PWD,
db=ION_MYSQL_DB)
cur = db.cursor()
cur.execute("""SELECT * FROM identities""")
identity_objs = cur.fetchall()
cur.execute("""SELECT * FROM profiles""")
profile_objs = cur.fetchall()
cur.execute("""SELECT * FROM skills""")
skills_objs = cur.fetchall()
total_count = len(identity_objs) + len(profile_objs) + len(skills_objs)
total_skills_count = len(skills_objs)
# call storage.all() method, both with and without class specified
all_objs = storage.all()
count1 = len(all_objs.keys())
all_skills_objs = storage.all(Skills)
skills_count1 = len(all_skills_objs.keys())
# tests that counts from all method match current database
self.assertEqual(total_count, count1)
self.assertEqual(total_skills_count, skills_count1)
# creates new Skills obj to test with
new_obj = Skills()
# adds all attributes required for testing
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj.name = "test_name"
# saves new object to the database
new_obj.save()
# re-call storage.all() method
all_objs = storage.all()
count2 = len(all_objs.keys())
all_skills_objs = storage.all(Skills)
skills_count2 = len(all_skills_objs.keys())
# tests that counts increased by 1
self.assertEqual(count1 + 1, count2)
self.assertEqual(skills_count1 + 1, skills_count2)
# deletes new object from the database
new_obj.delete()
# re-call storage.all() method
all_objs = storage.all()
count3 = len(all_objs.keys())
all_skills_objs = storage.all(Skills)
skills_count3 = len(all_skills_objs.keys())
# tests that count decreased by 1
self.assertEqual(count2 - 1, count3)
self.assertEqual(count1, count3)
self.assertEqual(skills_count2 - 1, skills_count3)
self.assertEqual(skills_count1, skills_count3)
def get(self):
if self.user:
projects = Projects.query(Projects.user == self.user).fetch(
limit=5)
categories = Categories.query(Categories.user == self.user).fetch()
skills = Skills.query(Skills.user == self.user).fetch()
self.render('welcome.html',
projects=projects,
categories=categories,
skills=skills)
else:
self.redirect('/login')
def test_all_skills_dict(self):
"""
tests return of all method when class is Skills
"""
# connect to MySQL database through MySQLdb and get initial count
db = connect(host=ION_MYSQL_HOST,
user=ION_MYSQL_USER,
passwd=ION_MYSQL_PWD,
db=ION_MYSQL_DB)
cur = db.cursor()
cur.execute("""SELECT * FROM skills""")
skills_objs = cur.fetchall()
total_skills_count = len(skills_objs)
# call storage.all() method
all_skills_objs = storage.all(Skills)
skills_count1 = len(all_skills_objs.keys())
# tests that all method returns same count of Skills objects
self.assertEqual(total_skills_count, skills_count1)
# tests that all method returns dictionary
self.assertIsInstance(all_skills_objs, dict)
# creates new Skills obj to test with
new_obj = Skills()
# adds all attributes required for testing
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj.name = "test_name"
# saves new object to the database
new_obj.save()
# re-call storage.all() method and test that count increased by 1
all_skills_objs = storage.all(Skills)
skills_count2 = len(all_skills_objs.keys())
self.assertEqual(skills_count1 + 1, skills_count2)
# tests that newly created obj is in dictionary with correct key
self.assertIsInstance(storage.all(), dict)
dict_key = "{}.{}".format("Skills", new_obj.id)
self.assertIn(dict_key, storage.all())
# get obj attributes from stroage.all() dictionary using obj id
# test that retrieved attributes match expected values
obj_class = storage.all().get("Skills.{}".format(
new_obj.id)).__class__.__name__
self.assertEqual("Skills", obj_class)
obj_name = storage.all().get("Skills.{}".format(new_obj.id)).name
self.assertEqual("test_name", obj_name)
# delete new object from the database
new_obj.delete()
# re-call storage.all() method and test that count decreased by 1
all_skills_objs = storage.all(Skills)
skills_count3 = len(all_skills_objs.keys())
self.assertEqual(skills_count2 - 1, skills_count3)
self.assertEqual(skills_count1, skills_count3)
# tests that new object is no longer in return dictionary
self.assertNotIn(dict_key, storage.all())
def test_updated_datetime_attributes(self):
"""
tests that the datetime attribute updated_at changes
when the save() method is implemented
"""
first_time = datetime.now()
new_obj = Skills()
second_time = datetime.now()
# tests if object's created_at time is between timestamps
self.assertTrue(first_time <= new_obj.created_at <= second_time)
# tests if object's updated_at is within the same timestamps
self.assertTrue(first_time <= new_obj.updated_at <= second_time)
# gets timestamps of current attributes and pauses a moment
original_created_at = new_obj.created_at
original_updated_at = new_obj.updated_at
sleep(1)
# adds required attributes so the object can be saved; saves object
new_obj.name = "test_name"
new_obj.save()
# tests that the object's updated_at has changed and is later
self.assertNotEqual(original_updated_at, new_obj.updated_at)
self.assertTrue(original_updated_at < new_obj.updated_at)
# tests that only the object's updated_at datetime has changed
self.assertEqual(original_created_at, new_obj.created_at)
def test_reload(self):
"""
tests that the reload function creates a new session
linked only to current database tables
"""
# connect to MySQL database through MySQLdb and get initial count
db = connect(host=ION_MYSQL_HOST,
user=ION_MYSQL_USER,
passwd=ION_MYSQL_PWD,
db=ION_MYSQL_DB)
cur = db.cursor()
cur.execute("""SELECT * FROM skills""")
skills_objs = cur.fetchall()
total_skills_count = len(skills_objs)
# call storage.all() method
all_skills_objs = storage.all(Skills)
skills_count1 = len(all_skills_objs.keys())
# tests that all method returns same count of Skills objects
self.assertEqual(total_skills_count, skills_count1)
# creates new Skills obj to test with; obj is saved
new_obj1 = Skills()
# adds all attributes required for testing
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj1.name = "test_name1"
# saves new object to the database
new_obj1.save()
# creates new Skills obj to test with; obj is not saved
new_obj2 = Skills()
# adds all attributes required for testing
# (id should be set by primary key)
# (created_at, updated_at should be set by datetime)
new_obj2.name = "test_name2"
# call reload method to reconnect session to current database
storage.reload()
# re-call storage.all() method and test that count increased by only 1
all_skills_objs = storage.all(Skills)
skills_count2 = len(all_skills_objs.keys())
self.assertEqual(skills_count1 + 1, skills_count2)
# tests that newly created saved obj is in dictionary with correct key
dict_key = "{}.{}".format("Skills", new_obj1.id)
self.assertIn(dict_key, storage.all())
# tests that newly created unsaved obj is not in dictionary
dict_key = "{}.{}".format("Skills", new_obj2.id)
self.assertNotIn(dict_key, storage.all())
def get(self, user_name):
user_other = User.by_name(user_name)
if user_other:
other_projects = Projects.query(
Projects.user.name == user_name).fetch()
other_categories = Categories.query(
Categories.user.name == user_name).fetch()
recent_projects = Projects.query(
Projects.user.name == user_name).fetch(limit=6)
other_skills = Skills.query(Skills.user.name == user_name).fetch()
self.render('visitmain.html',
recent_projects=recent_projects,
other_projects=other_projects,
other_categories=other_categories,
user_other=user_other,
other_skills=other_skills)
else:
self.render('errorpage.html',
error="Sorry, that user could not be found.")
from conn import Connection
from models.skills import Skills
import uuid
# to check user is exists or not, import function "skill_validation" from "Skills" class
skills = Skills()
class Education:
def __init__(self):
self.connection = Connection()
self.connection.connect_database()
def education_validation(self, content):
try:
self.content = content
for edu in self.content:
# check dictionary is empty or not
if not edu:
self.payload = "dictionary can not be empty", 200
return self.payload
if type(edu['type']) is not str:
self.payload = "degree type must be string", 200
return self.payload
if type(edu['name']) is not str:
self.payload = "degree name must be string", 200
return self.payload
if type(edu['is_completed']) is not bool:
def intern_skill_route(user_id):
if request.method == 'POST':
content = request.get_json()
skills = Skills()
return skills.add_skills(user_id, content)
elif request.method == 'PUT':
content = request.get_json()
skills = Skills()
return skills.update_skills(user_id, content)
elif request.method == 'GET':
skills = Skills()
return skills.get_skills(user_id)
else:
content = request.get_json()
skills = Skills()
return skills.delete_skills(user_id, content)
