def setUp(self):
super().setUp()
self.user_rule = UserRule()
self.user = self.user_rule.user
self.random_origin_word = self.faker.word()
self.random_origin_language = LanguageRule().random
self.user_word_rule = UserWordRule(self.random_origin_word,
self.random_origin_language)
def test_languages_exists(self):
language_should_be = LanguageRule().random
try:
language_to_check = Language.find(language_should_be.code)
except NoResultFound:
assert False, "No Language found in database"
assert language_should_be.code == language_to_check.code \
and language_should_be.name == language_to_check.name
def _create_model_object(self):
random_word = self.faker.word()
random_language = LanguageRule().random
user_word = UserWord(random_word, random_language)
if self._exists_in_db(user_word):
return self._create_model_object()
return user_word
def _create_model_object(self, length):
random_content = self.faker.text(max_nb_chars=length)
random_language = LanguageRule().random
random_url = UrlRule().url
text = Text(random_content, random_language, random_url)
if self._exists_in_db(text):
return self._create_model_object(length)
return text
def _create_model_object(self):
random_email = self.faker.simple_profile()['mail']
random_name = self.faker.name()
random_password = self.faker.password()
random_learned_language = LanguageRule().random
random_native_language = LanguageRule().random
while random_native_language.id == random_learned_language.id:
random_native_language = LanguageRule().random
user = User(random_email,
random_name,
random_password,
learned_language=random_learned_language,
native_language=random_native_language)
if self._exists_in_db(user):
return self._create_model_object()
return user
def _create_model_object(self, user, **kwargs):
bookmark = None
while not bookmark:
random_url = UrlRule().url
random_text = TextRule().text
random_origin_word = self.faker.word()
random_origin_language = LanguageRule().random
random_translation_word = self.faker.word()
random_translation_language = LanguageRule().random
if UserWord.exists(random_origin_word, random_origin_language) \
or UserWord.exists(random_translation_word, random_translation_language):
return self._create_model_object(user)
random_origin = UserWordRule(random_origin_word,
random_origin_language).user_word
random_translation = UserWordRule(
random_translation_word, random_translation_language).user_word
random_date = self.faker.date_time_this_month()
bookmark = Bookmark(random_origin, random_translation, user,
random_text, random_date)
if not bookmark.quality_bookmark():
bookmark = False
# print ("random bookmark was of low quality. retrying...")
for k in kwargs:
if k in self.props:
setattr(bookmark, k, kwargs.get(k))
if self._exists_in_db(bookmark):
return self._create_model_object(user)
return bookmark
def setUp(self):
super().setUp()
self.user_rule = UserRule()
self.user = self.user_rule.user
self.url_rule = UrlRule()
self.url = self.url_rule.url
self.url_rule2 = UrlRule()
self.url2 = self.url_rule2.url
self.language_rule = LanguageRule()
self.language = self.language_rule.en
def test_native_language(self):
language_should_be = LanguageRule().random
self.user.set_native_language(language_should_be.code)
assert self.user.native_language.id == language_should_be.id
def test_user_set_language(self):
language_should_be = LanguageRule().random
self.user.set_learned_language(language_should_be.code)
assert self.user.learned_language.id == language_should_be.id
def test_get_all_languages(self):
languages = LanguageRule.languages
for lan in languages:
assert LanguageRule.get_or_create_language(lan)
def setUp(self):
super().setUp()
self.user = UserRule().user
self.lan = LanguageRule().de