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')