def _create_model_object(self, user, force_quality=True, **kwargs):
"""
Creates a Bookmark object with random data.
Behind the random words, a random number is added since the Faker library does not have too many RANDOM words
and random words get repeated whenever many random bookmarks are created. To overcome the problem of bookmarks
with duplicate words in the database, a random number is added.
Also, if force_quality is set (default) and the bookmark is not .quality_bookmark() the process is
reiterated till this is true. This simplifies some of the tests
:param user: User Object, to which the bookmark is assigned.
:param kwargs: Holds any of the 'props' as key if a field should not be random
:return:
"""
bookmark = None
while not bookmark:
from tests_zeeguu.rules.text_rule import TextRule
random_text = TextRule().text
random_origin_word = self.faker.word() + str(random.random())
random_origin_language = LanguageRule().random
random_translation_word = self.faker.word() + str(random.random())
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()
from tests_zeeguu.rules.article_rule import ArticleRule
random_article = ArticleRule(real=True).article
bookmark = Bookmark(random_origin, random_translation, user,
random_text, random_date)
if force_quality and not bookmark.quality_bookmark():
# print ("random bookmark was of low quality. retrying...")
bookmark = False
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.db.session.add(self.user)
self.db.session.commit()
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)
self.text = "This sentence, taken as a reading passage unto itself, is being used to prove a point."
self.english = LanguageRule().get_or_create_language("en")
def test_importance_level(self):
random_word_stats = self.__get_random_word_stats()
random_language = LanguageRule().get_or_create_language(
random_word_stats[1].language_id)
user_word = UserWord(random_word_stats[0], random_language)
assert user_word.importance_level() == int(
random_word_stats[1].importance)
def _create_model_object(self, *args):
name = self.faker.word()
inv_code = self.faker.word()
max_students = 10
language = LanguageRule().random
cohort = Cohort(inv_code, name, language, max_students)
return cohort
def test_find_or_create(self):
random_word = self.faker.word()
random_language = LanguageRule().random
user_word_not_in_db = UserWord(random_word, random_language)
user_word_created = UserWord.find_or_create(self.db.session,
random_word,
random_language)
assert user_word_created == user_word_not_in_db
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 test_find_by_language(self):
random_language = LanguageRule().random
list_random_user_words = [
UserWordRule(word=self.faker.word(),
language=random_language).user_word
for _ in range(random.randint(2, 5))
]
list_retrieved = UserWord.find_by_language(random_language)
assert all([word in list_retrieved for word in list_random_user_words])
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):
title = " ".join(self.faker.text().split()[:(randint(1, 10))])
description = " ".join(self.faker.text().split()[:(randint(5, 20))])
language = LanguageRule().random
url = UrlRule().url
image_url = UrlRule().url
new_rss_feed = RSSFeed(url, title, description, image_url, language)
if RSSFeed.exists(new_rss_feed):
return self._create_model_object()
return new_rss_feed
def _create_model_object(self, length):
random_content = self.faker.text(max_nb_chars=length)
random_language = LanguageRule().random
random_article = ArticleRule().article
random_url = random_article.url
text = Text(random_content, random_language, random_url,
random_article)
if self._exists_in_db(text):
return self._create_model_object(length)
return text
def _create_model_object(self, word=None, language=None):
tmp_word = word
tmp_language = language
if tmp_word is None:
tmp_word = self.faker.word()
if tmp_language is None:
tmp_language = LanguageRule().random
user_word = UserWord(tmp_word, tmp_language)
if self._exists_in_db(user_word):
return self._create_model_object(word, language)
return user_word
def _create_model_object(self):
title = " ".join(self.faker.text().split()[:4])
authors = self.faker.name()
content = self.faker.text()
summary = self.faker.text()
published = datetime.now() - timedelta(minutes=randint(0, 7200))
rss_feed = RSSFeedRule().feed
language = LanguageRule().random
url = UrlRule().url
article = Article(url, title, authors, content, summary, published,
rss_feed, language)
if self._exists_in_db(article):
return self._create_model_object()
return article
def test_german_medium(self):
lan = LanguageRule().de
d = FleschKincaidDifficultyEstimator.estimate_difficulty(DE_MEDIUM_TEXT, lan, self.user)
self.assertEqual('MEDIUM', d['discrete'])
def __get_random_word_stats(self):
random_language = LanguageRule().random
language_stats = load_language_from_hermit(random_language.code)
return random.choice(list(language_stats.word_info_dict.items()))
def setUp(self):
super().setUp()
self.article1 = ArticleRule().article
self.article2 = ArticleRule().article
self.language = LanguageRule.get_or_create_language("en")
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_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 setUp(self):
super().setUp()
self.user = UserRule().user
self.lan = LanguageRule().de
def test_get_all_languages(self):
languages = LanguageRule.languages
for lan in languages:
assert LanguageRule.get_or_create_language(lan)
def test_german_constants(self):
lan = LanguageRule().de
constants = FleschKincaidDifficultyEstimator.get_constants_for_language(lan)
self.assertEqual(180, constants["start"])
self.assertEqual(1, constants["sentence"])
self.assertEqual(58.5, constants["word"])
def test_english_constants(self):
lan = LanguageRule().en
constants = FleschKincaidDifficultyEstimator.get_constants_for_language(lan)
self.assertEqual(206.835, constants["start"])
self.assertEqual(1.015, constants["sentence"])
self.assertEqual(84.6, constants["word"])
def test_german_hard(self):
lan = LanguageRule().de
d = FleschKincaidDifficultyEstimator.estimate_difficulty(DE_HARD_TEXT, lan, self.user)
self.assertEqual('HARD', d['discrete'])
def test_english_medium(self):
lan = LanguageRule().en
d = FleschKincaidDifficultyEstimator.estimate_difficulty(E_MEDIUM_TEXT, lan, self.user)
self.assertEqual(d['discrete'], 'MEDIUM')
def test_english_hard(self):
lan = LanguageRule().en
d = FleschKincaidDifficultyEstimator.estimate_difficulty(E_HARD_TEXT, lan, self.user)
self.assertEqual(d['discrete'], 'HARD')