def __init__(self):
self.persons = []
self.profiles = []
self.experiences = []
self.saves = []
self.search_repo = Mock()
self.repo = ExperienceRepo(self.search_repo)
def given_an_experience_from_blocked_person(self,
title='',
description='',
saves_count=0):
experience = Experience(id=str(len(self.experiences) + 1),
title=title,
description=description,
author_id=self.orm_blocked_person.id,
author_profile=Profile(
person_id=self.orm_blocked_person.id,
username='******',
bio='cked',
picture=None,
is_me=False),
saves_count=saves_count,
is_mine=False)
db_experience = ExperienceRepo().create_experience(experience)
ORMExperience.objects.filter(id=db_experience.id).update(
saves_count=saves_count)
experience = experience.builder().id(db_experience.id).build()
self.experiences.append(experience)
return self
def when_unsave_that_experience(self):
try:
self.result = ExperienceRepo().unsave_experience(
person_id=self.orm_person.id,
experience_id=self.orm_experience_a.id)
except Exception as e:
self.error = e
return self
def test_get_all_experiences_returns_all_experiences(self):
orm_exp_a = ORMExperience.objects.create(
title='Exp a', description='some description')
orm_exp_b = ORMExperience.objects.create(
title='Exp b', description='other description')
result = ExperienceRepo().get_all_experiences()
exp_a = Experience(id=orm_exp_a.id,
title='Exp a',
description='some description',
picture=None)
exp_b = Experience(id=orm_exp_b.id,
title='Exp b',
description='other description',
picture=None)
assert result == [exp_a, exp_b]
def test_saved_experiences_returns_only_saved_scenes(self):
orm_person = ORMPerson.objects.create()
ORMProfile.objects.create(person_id=orm_person.id, username='******')
orm_person_b = ORMPerson.objects.create()
ORMProfile.objects.create(person_id=orm_person_b.id,
username='******',
bio='bs')
orm_auth_token = ORMAuthToken.objects.create(person=orm_person)
exp_a = ORMExperience.objects.create(title='Exp a',
description='some description',
author=orm_person_b)
ORMExperience.objects.create(title='Exp b',
description='other description',
author=orm_person_b)
ExperienceRepo().save_experience(orm_person.id, exp_a.id)
client = Client()
auth_headers = {
'HTTP_AUTHORIZATION':
'Token {}'.format(orm_auth_token.access_token),
}
response = client.get("{}?saved=true".format(reverse('experiences')),
**auth_headers)
assert response.status_code == 200
body = json.loads(response.content)
assert body == {
'results': [{
'id': str(exp_a.id),
'title': 'Exp a',
'description': 'some description',
'picture': None,
'author_profile': {
'username': '******',
'bio': 'bs',
'picture': None,
'is_me': False,
},
'is_mine': False,
'is_saved': True,
'saves_count': 1
}],
'next_url':
None
}
def when_create_this_experience(self):
self._result = ExperienceRepo().create_experience(
self._experience_to_create)
return self
def when_get_unexistent_experience(self):
try:
ExperienceRepo().get_experience(0)
except EntityDoesNotExistException as e:
self._entity_does_not_exist_error = e
return self
def when_get_experience_with_its_id(self):
self._result = ExperienceRepo().get_experience(
self._orm_experience_a.id)
return self
def when_get_all_experiences(self):
self._result = ExperienceRepo().get_all_experiences()
return self
def then_should_save_this_experience_to_db(self):
exp = ExperienceRepo().get_experience(self._result.id)
assert exp.title == self._experience_to_create.title
assert exp.description == self._experience_to_create.description
return self
def when_update_first_experience(self):
self._result = ExperienceRepo().update_experience(
self._updated_experience)
return self
def test_others_experiences_returns_others_experiences(self):
orm_person = ORMPerson.objects.create()
ORMProfile.objects.create(person_id=orm_person.id, username='******')
orm_auth_token = ORMAuthToken.objects.create(person=orm_person)
orm_other_person = ORMPerson.objects.create()
ORMProfile.objects.create(person_id=orm_other_person.id,
username='******',
bio='c')
exp_a = ORMExperience.objects.create(title='Exp a',
description='some description',
author=orm_other_person)
exp_b = ORMExperience.objects.create(title='Exp b',
description='other description',
author=orm_other_person)
exp_c = ORMExperience.objects.create(title='Exp c',
description='third description',
author=orm_other_person)
ExperienceRepo().save_experience(person_id=orm_person.id,
experience_id=exp_c.id)
client = Client()
auth_headers = {
'HTTP_AUTHORIZATION':
'Token {}'.format(orm_auth_token.access_token),
}
response = client.get(
"{}?username=other&limit=2".format(reverse('experiences')),
**auth_headers)
assert response.status_code == 200
body = json.loads(response.content)
assert body == {
'results': [
{
'id': str(exp_c.id),
'title': 'Exp c',
'description': 'third description',
'picture': None,
'author_profile': {
'username': '******',
'bio': 'c',
'picture': None,
'is_me': False,
},
'is_mine': False,
'is_saved': True,
'saves_count': 1
},
{
'id': str(exp_b.id),
'title': 'Exp b',
'description': 'other description',
'picture': None,
'author_profile': {
'username': '******',
'bio': 'c',
'picture': None,
'is_me': False,
},
'is_mine': False,
'is_saved': False,
'saves_count': 0
},
],
'next_url':
'https://testserver/experiences/?username=other&limit=2&offset=2'
}
auth_headers = {
'HTTP_AUTHORIZATION':
'Token {}'.format(orm_auth_token.access_token),
}
response = client.get(body['next_url'], **auth_headers)
assert response.status_code == 200
body = json.loads(response.content)
assert body == {
'results': [
{
'id': str(exp_a.id),
'title': 'Exp a',
'description': 'some description',
'picture': None,
'author_profile': {
'username': '******',
'bio': 'c',
'picture': None,
'is_me': False,
},
'is_mine': False,
'is_saved': False,
'saves_count': 0
},
],
'next_url':
None
}
class ScenarioMaker:
def __init__(self):
self.persons = []
self.profiles = []
self.experiences = []
self.saves = []
self.search_repo = Mock()
self.repo = ExperienceRepo(self.search_repo)
def given_a_person_in_db(self, username):
self.persons.append(ORMPerson.objects.create())
self.profiles.append(
ORMProfile.objects.create(
person=self.persons[len(self.persons) - 1],
username=username))
return self
def given_an_experience_in_db(self,
created_by_person,
share_id=None,
is_deleted=False):
author_id = self.persons[created_by_person - 1].id
self.experiences.append(
ORMExperience.objects.create(author_id=author_id,
share_id=share_id,
is_deleted=is_deleted))
return self
def given_I_save_experience(self, experience):
experience_id = str(self.experiences[experience - 1].id)
self.repo.save_experience(person_id=str(self.persons[0].id),
experience_id=experience_id)
self.saves.append(experience_id)
return self
def given_a_word_location_limit_and_offset(self):
self.word = 'culture'
self.location = (5.4, -0.8)
self.offset = 4
self.limit = 10
return self
def given_a_search_repo_that_returns_experience_ids_and_offset(
self, experiences_positions, offset):
experiences_ids = [
self.experiences[i - 1].id for i in experiences_positions
]
self.search_repo.search_experiences.return_value = {
'results': experiences_ids,
'next_offset': offset
}
return self
def when_get_saved_experiences(self, offset, limit):
self.result = self.repo.get_saved_experiences(logged_person_id=str(
self.persons[0].id),
offset=offset,
limit=limit)
return self
def when_get_person_experiences(self, target_person, offset, limit):
self.result = self.repo.get_person_experiences(
logged_person_id=str(self.persons[0].id),
target_person_id=str(self.persons[target_person - 1].id),
offset=offset,
limit=limit)
return self
def when_get_experience(self, position, person=0):
try:
self.result = self.repo.get_experience(
id=str(self.experiences[position - 1].id),
logged_person_id=str(self.persons[person - 1].id))
except EntityDoesNotExistException as e:
self.entity_does_not_exist_exception = e
return self
def when_get_experience_by_share_id(self, share_id, person=0):
try:
self.result = self.repo.get_experience(
share_id=share_id,
logged_person_id=str(self.persons[person - 1].id))
except EntityDoesNotExistException as e:
self.entity_does_not_exist_exception = e
return self
def when_get_unexistent_experience(self):
try:
self.repo.get_experience(id='0')
except EntityDoesNotExistException as e:
self.entity_does_not_exist_exception = e
return self
def when_create_experience(self, title, description, author):
orm_author = self.persons[author - 1]
experience = Experience(title=title,
description=description,
author_id=str(orm_author.id))
self.result = self.repo.create_experience(experience)
return self
def when_update_experience(self,
experience,
title,
description,
share_id=None):
experience = self.repo._decode_db_experience(
ORMExperience.objects.get(id=str(self.experiences[experience -
1].id)),
logged_person_id=str(self.persons[0].id))
updated_experience = experience.builder().title(title).description(
description).share_id(share_id).build()
try:
self.result = self.repo.update_experience(
updated_experience,
logged_person_id=str(self.persons[0].id))
except EntityDoesNotExistException as e:
self.entity_does_not_exist_exception = e
except Exception as e:
self.error = e
return self
def when_save_experience(self, position):
experience = self.experiences[position - 1]
self.result = self.repo.save_experience(
person_id=str(self.persons[0].id),
experience_id=str(experience.id))
return self
def when_unsave_experience(self, position):
experience = self.experiences[position - 1]
self.result = self.repo.unsave_experience(
person_id=str(self.persons[0].id),
experience_id=str(experience.id))
return self
def when_flag_experience(self, position, reason):
self.result = self.repo.flag_experience(
person_id=str(self.persons[0].id),
experience_id=str(self.experiences[position - 1].id),
reason=reason)
return self
def when_search_experiences(self):
self.result = self.repo.search_experiences(str(self.persons[0].id),
self.word,
self.location,
self.offset, self.limit)
return self
def then_result_should_be_experiences_and_offset(
self, experiences_positions, next_offset):
assert self.result['next_offset'] == next_offset
assert len(self.result['results']) == len(experiences_positions)
for i in range(len(experiences_positions)):
orm_experience = self.experiences[experiences_positions[i] - 1]
orm_experience.refresh_from_db()
saved = str(orm_experience.id) in self.saves
parsed_experience = self.repo._decode_db_experience(
orm_experience, str(self.persons[0].id), is_saved=saved)
assert self.result['results'][i] == parsed_experience
return self
def then_repo_should_return_experience(self,
position,
person_logged,
saved=False):
orm_experience = self.experiences[position - 1]
parsed_experience = self.repo._decode_db_experience(
orm_experience,
str(self.persons[person_logged - 1].id),
is_saved=saved)
if saved:
parsed_experience = parsed_experience.builder().saves_count(
1).build()
assert self.result == parsed_experience
return self
def then_entity_does_not_exists_should_be_raised(self):
assert self.entity_does_not_exist_exception is not None
return self
def then_should_return_experience(self,
title,
description,
author,
mine,
share_id=None):
assert self.result.title == title
assert self.result.description == description
assert self.result.author_profile.person_id == str(
self.profiles[author - 1].person_id)
assert self.result.author_profile.username == self.profiles[
author - 1].username
assert self.result.author_profile.bio == self.profiles[author -
1].bio
assert self.result.author_profile.is_me == mine
assert self.result.is_mine == mine
assert self.result.share_id == share_id
return self
def then_result_experience_should_be_in_db(self):
orm_experience = ORMExperience.objects.get(id=self.result.id)
assert str(orm_experience.id) == self.result.id
assert orm_experience.title == self.result.title
assert orm_experience.description == self.result.description
assert str(orm_experience.author.profile.person_id
) == self.result.author_profile.person_id
assert orm_experience.author.profile.username == self.result.author_profile.username
assert orm_experience.author.profile.bio == self.result.author_profile.bio
assert orm_experience.share_id == self.result.share_id
return self
def then_result_should_be_true(self):
assert self.result is True
return self
def then_save_should_be_in_db(self, how_many_saves, person,
experience):
orm_person = self.persons[person - 1]
orm_experience = self.experiences[experience - 1]
assert len(
ORMSave.objects.filter(
experience_id=orm_experience.id,
person_id=orm_person.id)) == how_many_saves
return self
def then_flag_should_be_in_db(self, person, experience, reason):
orm_person = self.persons[person - 1]
orm_experience = self.experiences[experience - 1]
assert len(
ORMFlag.objects.filter(experience_id=orm_experience.id,
person_id=orm_person.id,
reason=reason)) == 1
return self
def then_experience_saves_count_should_be(self, experience,
saves_count):
self.experiences[experience - 1].refresh_from_db()
assert self.experiences[experience - 1].saves_count == saves_count
return self
def then_should_call_search_repo_search_experiences_with_correct_params(
self):
self.search_repo.search_experiences.assert_called_once_with(
self.word, self.location, self.offset, self.limit)
return self
def then_should_raise_conflict_exception(self):
assert type(self.error) == ConflictException
return self
def when_get_all_experiences(self, mine=False, saved=False):
self.result = ExperienceRepo().get_all_experiences(
logged_person_id=self.logged_person_id, mine=mine, saved=saved)
return self