def session(item_id, review_id, review_question_id, user_id):
session = get_db_session(True, None)
item = Item()
item.id = item_id
user = User()
user.id = user_id
level = Level(id=1)
review = Review()
review.id = review_id
review.item_id = item.id
review.user_id = user.id
review_question = ReviewQuestion()
review_question.id = review_question_id
review_question.content = "Question content"
review_question.info = "Question info"
review_question.hint = "Question hint"
o1 = AnswerOption(id="1", text="Option 1", value=0)
o2 = AnswerOption(id="2", text="Option 2", value=1, tooltip="Tooltip 2")
o3 = AnswerOption(id="3", text="Option 3", value=2)
o4 = AnswerOption(id="4", text="Option 4", value=3)
o1.questions = [review_question]
o2.questions = [review_question]
o4.questions = [review_question]
o3.questions = [review_question]
# all answers use the same review questions in order to keep the test data small
reviewanswer1 = generate_review_answer(1, review_id, review_question_id)
reviewanswer2 = generate_review_answer(0, review_id, review_question_id)
reviewanswer3 = generate_review_answer(1, review_id, review_question_id)
reviewanswer4 = generate_review_answer(3, review_id, review_question_id)
reviewanswer5 = generate_review_answer(2, review_id, review_question_id)
reviewanswer6 = generate_review_answer(1, review_id, review_question_id)
reviewanswer7 = generate_review_answer(2, review_id, review_question_id)
review.review_answers = [reviewanswer1, reviewanswer2, reviewanswer3,
reviewanswer4, reviewanswer5, reviewanswer6, reviewanswer7]
session.add(item)
session.add(user)
session.add(level)
session.add(review_question)
# refernenced ReviewAnswers are stored as well
session.add(review)
session.commit()
return session
def test_tags_to_dict():
with Session() as session:
user = User(id=str(uuid4()), name='user1')
level = Level(id=1, description='beginner')
item = Item(id=str(uuid4()), content='item')
tag1 = Tag(id=str(uuid4()), tag='tag1')
tag2 = Tag(id=str(uuid4()), tag='tag2')
tag3 = Tag(id=str(uuid4()), tag='tag3')
review = Review()
review.id = str(uuid4())
review.is_peer_review = False
review.user_id = user.id
review.item_id = item.id
session.add_all([user, item, tag1, tag2, tag3, review, level])
session.commit()
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 0
item_tag1 = ItemTag(id=str(uuid4()),
item_id=item.id,
tag_id=tag1.id,
review_id=review.id)
session.add(item_tag1)
session.commit()
session.refresh(review)
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 1
assert review_dict['tags'][0] == 'tag1'
item_tag2 = ItemTag(id=str(uuid4()),
item_id=item.id,
tag_id=tag2.id,
review_id=review.id)
session.add(item_tag2)
session.commit()
session.refresh(review)
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 2
assert 'tag2' in review_dict['tags']
session.delete(item_tag1)
session.commit()
session.refresh(review)
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 1
assert review_dict['tags'][0] == 'tag2'
def create_user(event, context):
logger = logging.getLogger()
logger.setLevel(logging.INFO)
helper.log_method_initiated("Create user from cognito", event, logger)
with Session() as session:
if event['triggerSource'] == "PostConfirmation_ConfirmSignUp":
user = User()
user.name = event['userName']
user.id = event['request']['userAttributes']['sub']
if user.id == None or user.name == None:
raise Exception("Something went wrong!")
user = user_handler.create_user(user, session)
client = boto3.client('cognito-idp')
client.admin_add_user_to_group(UserPoolId=event['userPoolId'],
Username=user.name,
GroupName='Detective')
return event
def test_post_comment_on_item(event, item_id, user_id):
with Session() as session:
item_obj = Item(id=item_id)
user_obj = User(id=user_id, name='Testuser')
level_1_obj = Level(id=1)
session.add_all([item_obj, level_1_obj, user_obj])
session.commit()
response = post_comment_on_item(event)
body = json.loads(response['body'])
assert body['user'] == 'Testuser'
comment = session.query(Item).all()[
0].comments[0]
assert comment.comment == "Comment from event"
assert comment.is_review_comment == False
assert comment.status == "published"
def create_levels_junior_and_senior_detectives(session):
"""
This method can be used to setup a testing scenario.
It adds the following objects to a session:
- 3 levels requiring 0, 5 and 10 experience points
- 4 detectives with level 1 and ids 1 - 4
- 4 detectives with level 2 and ids 11 - 14
"""
# Create three levels
level1 = create_level(1, "Junior", 0)
level2 = create_level(2, "Senior", 5)
level3 = create_level(3, "Master", 10)
session.add(level1)
session.add(level2)
session.add(level3)
# Create 5 level-1-detectives
junior_detective1 = User()
junior_detective1.id = "1"
junior_detective1.name = "Junior1"
user_handler.create_user(junior_detective1, session)
junior_detective2 = User()
junior_detective2.id = "2"
junior_detective2.name = "Junior2"
user_handler.create_user(junior_detective2, session)
junior_detective3 = User()
junior_detective3.id = "3"
junior_detective3.name = "Junior3"
user_handler.create_user(junior_detective3, session)
junior_detective4 = User()
junior_detective4.id = "4"
junior_detective4.name = "Junior4"
user_handler.create_user(junior_detective4, session)
junior_detective5 = User()
junior_detective5.id = "5"
junior_detective5.name = "Junior5"
user_handler.create_user(junior_detective5, session)
# Create 5 level-2-detectives
senior_detective1 = User()
senior_detective1.id = "11"
senior_detective1.name = "Senior1"
senior_detective1 = user_handler.create_user(senior_detective1, session)
senior_detective1.level_id = 2
senior_detective1.experience_points = 5
senior_detective2 = User()
senior_detective2.id = "12"
senior_detective2.name = "Senior2"
senior_detective2 = user_handler.create_user(senior_detective2, session)
senior_detective2.level_id = 2
senior_detective2.experience_points = 5
senior_detective3 = User()
senior_detective3.id = "13"
senior_detective3.name = "Senior3"
senior_detective3 = user_handler.create_user(senior_detective3, session)
senior_detective3.level_id = 2
senior_detective3.experience_points = 5
senior_detective4 = User()
senior_detective4.id = "14"
senior_detective4.name = "Senior4"
senior_detective4 = user_handler.create_user(senior_detective4, session)
senior_detective4.level_id = 2
senior_detective4.experience_points = 5
senior_detective5 = User()
senior_detective5.id = "15"
senior_detective5.name = "Senior5"
senior_detective5 = user_handler.create_user(senior_detective5, session)
senior_detective5.level_id = 2
senior_detective5.experience_points = 5
session.merge(senior_detective1)
session.merge(senior_detective2)
session.merge(senior_detective3)
session.merge(senior_detective4)
session.merge(senior_detective5)
session.commit()
return session
def create_users_for_ranking(session):
"""
Creates My Detective looking up ranking and his own position
3 different Levels (Junior, Senior, Master)
20 Users on Junior Level, 20 Users on Senior Level, 20 Users on Master Level
"""
levels_to_create = [{
'id': 1,
'description': 'Junior',
'required_experience_points': 0
}, {
'id': 2,
'description': 'Senior',
'required_experience_points': 20
}, {
'id': 3,
'description': 'Master',
'required_experience_points': 40
}]
level1_id = levels_to_create[0]['id']
level2_id = levels_to_create[1]['id']
level3_id = levels_to_create[2]['id']
for level in levels_to_create:
new_level = session.query(Level).get(level['id'])
if new_level is None:
new_level = create_level(level['id'], level['description'],
level['required_experience_points'])
session.add(new_level)
my_detective = User()
my_detective.id = "999"
my_detective.name = "MyDetektiv"
user_handler.create_user(my_detective, session)
my_detective.level_id = 2
my_detective.experience_points = 35
my_detective.sign_up_timestamp = datetime.today()
users_to_create = []
# the last created will be 60
for i in range(1, 21):
junior_user = User()
junior_user.id = str(i)
junior_user = user_handler.create_user(junior_user, session)
junior_user.name = "JuniorUser" + str(i)
junior_user.level_id = level1_id
junior_user.experience_points = i
junior_user.sign_up_timestamp = datetime.today() - timedelta(days=i)
users_to_create.append(junior_user)
for i in range(21, 41):
senior_user = User()
senior_user.id = str(i)
senior_user = user_handler.create_user(senior_user, session)
senior_user.name = "SeniorUser" + str(i)
senior_user.level_id = level2_id
senior_user.experience_points = i
senior_user.sign_up_timestamp = datetime.today() - timedelta(days=i)
users_to_create.append(senior_user)
for i in range(41, 61):
master_user = User()
master_user.id = str(i)
master_user = user_handler.create_user(master_user, session)
master_user.name = "MasterUser" + str(i)
master_user.level_id = level3_id
master_user.experience_points = i
master_user.sign_up_timestamp = datetime.today() - timedelta(days=i)
users_to_create.append(master_user)
session.add_all(users_to_create)
session.commit()
return session
def test_comment_model(event, item_id, user1_id, user2_id, submission_id):
with Session() as session:
item_obj = Item(id=item_id)
user1_obj = User(id=user1_id)
user2_obj = User(id=user2_id)
level_1_obj = Level(id=1)
submission_obj = Submission(id=submission_id)
session.add_all(
[item_obj, level_1_obj, user1_obj, user2_obj, submission_obj])
session.commit()
"""
Test comment on item
"""
body = event['body']
# Save qualitative_comment
comment_handler.create_comment(session,
comment=body['comment'],
user_id=user1_id,
parent_type='item',
parent_id=item_id)
# Asserts
comment_on_item = session.query(Comment).filter(
Comment.item_id.isnot(None)).first()
assert comment_on_item.comment == 'Comment from event'
assert comment_on_item.item_id == item_id
assert comment_on_item.user_id == user1_id
assert comment_on_item.status == 'published'
assert session.query(
Item).first().comments[0].comment == 'Comment from event'
"""
Test comment on submission
"""
# Save qualitative_comment
comment_handler.create_comment(session,
comment='Comment on submission',
user_id=user1_id,
parent_type='submission',
parent_id=submission_id)
# Asserts
comment_on_submission = session.query(Comment).filter(
Comment.submission_id.isnot(None)).first()
assert comment_on_submission.comment == 'Comment on submission'
assert comment_on_submission.submission_id == submission_id
assert comment_on_submission.user_id == user1_id
assert session.query(
Submission).first().comments[0].comment == 'Comment on submission'
"""
Test comment on comment
"""
# Save qualitative_comment on first comment ('Comment from event')
first_comment_id = session.query(Comment).first().id
comment_handler.create_comment(session,
comment='Comment on comment',
user_id=user2_id,
parent_type='comment',
parent_id=first_comment_id)
# Asserts
comment_on_comment = session.query(Comment).filter(
Comment.parent_comment_id.isnot(None)).first()
assert comment_on_comment.comment == 'Comment on comment'
assert comment_on_comment.parent_comment_id == first_comment_id
assert comment_on_comment.user_id == user2_id
assert comment_on_comment.parent_comment.comment == 'Comment from event'
"""
Test comment sentiment
"""
# Save sentiment on on first comment ('Comment from event')
sentiment_obj = CommentSentiment(id=str(uuid4()),
type='like',
user_id=user2_id,
comment_id=first_comment_id)
session.add(sentiment_obj)
session.commit()
sentiment = session.query(CommentSentiment).first()
assert sentiment.type == 'like'
assert sentiment.user_id == user2_id
assert sentiment.comment_id == first_comment_id
assert session.query(
Comment).first().comment_sentiments[0].type == 'like'
"""
Test issue about comment
"""
# Create issue on on first comment ('Comment from event')
issue_obj = Issue(category='Beleidigung',
message='der hat mich Blödmann genannt',
comment_id=first_comment_id)
session.add(issue_obj)
session.commit()
issue = session.query(Issue)
assert issue.count() == 1
assert len(session.query(Comment).first().issues) == 1
assert session.query(
Issue).first().comment.comment == 'Comment from event'
def test_get_review(item_id, review_id, review_question_id, user_id, tag_id,
item_tag_id, monkeypatch):
"""
Gets a simple Review
"""
monkeypatch.setenv("CORS_ALLOW_ORIGIN", "http://localhost:4200")
with Session() as session:
item = Item()
item.id = item_id
user = User()
user.id = user_id
level = Level(id=1)
review = Review()
review.id = review_id
review.item_id = item.id
review.user_id = user.id
review.status = 'in_progress'
tag = Tag(tag='test', id=tag_id)
item_tag = ItemTag(id=item_tag_id,
item_id=item_id,
tag_id=tag_id,
review_id=review_id)
comment = Comment(id='comment_id',
comment='testcomment',
review_id=review_id,
is_review_comment=True)
review_question = ReviewQuestion()
review_question.id = review_question_id
review_question.content = "Question content"
review_question.info = "Question info"
review_question.hint = "Question hint"
o1 = AnswerOption(id="1", text="Option 1", value=0)
o2 = AnswerOption(id="2",
text="Option 2",
value=1,
tooltip="Tooltip 2")
o3 = AnswerOption(id="3", text="Option 3", value=2)
o4 = AnswerOption(id="4", text="Option 4", value=3)
o1.questions = [review_question]
o2.questions = [review_question]
o4.questions = [review_question]
o3.questions = [review_question]
# all answers use the same review questions in order to keep the test data small
reviewanswer1 = generate_review_answer(1, review_id,
review_question_id)
reviewanswer2 = generate_review_answer(0, review_id,
review_question_id)
reviewanswer3 = generate_review_answer(1, review_id,
review_question_id)
reviewanswer4 = generate_review_answer(3, review_id,
review_question_id)
reviewanswer5 = generate_review_answer(2, review_id,
review_question_id)
reviewanswer6 = generate_review_answer(1, review_id,
review_question_id)
reviewanswer7 = generate_review_answer(2, review_id,
review_question_id)
review.review_answers = [
reviewanswer1, reviewanswer2, reviewanswer3, reviewanswer4,
reviewanswer5, reviewanswer6, reviewanswer7
]
session.add(item)
session.add(user)
session.add(level)
session.add(review_question)
session.add_all([tag, item_tag, comment])
# referenced ReviewAnswers are stored as well
session.add(review)
session.commit()
event = event_creator.get_get_review_event(user_id, review_id)
resp = get_review(event, None)
status = resp["statusCode"]
assert status == 200
body = json.loads(resp["body"])
assert body["id"] == review_id
assert len(body["questions"]) == 7
assert body["questions"][0]["answer_id"] != None
assert body["questions"][0]["question_id"] != None
assert body["questions"][0]["parent_question_id"] == None
assert body["questions"][0]["max_children"] == None
assert body["questions"][0]["content"] != None
assert body["questions"][0]["info"] != None
assert body["questions"][0]["hint"] != None
assert body["questions"][0]["answer_value"] == 1
assert len(body["questions"][0]["options"]) == 4
assert body["questions"][0]["options"][0]["text"] != None
assert body["questions"][0]["options"][0]["value"] == 0
assert body["questions"][0]["options"][1]["tooltip"] != None
assert 'tags' in body
assert len(body['tags']) == 1
assert body['tags'][0] == 'test'
assert 'comment' in body
assert body['comment'] == 'testcomment'