def test_get_tuto_count(self): # Start with 0 self.assertEqual(self.user1.get_tuto_count(), 0) # Create Tuto ! minituto = MiniTutorialFactory() minituto.authors.add(self.user1.user) minituto.gallery = GalleryFactory() minituto.save() # Should be 1 self.assertEqual(self.user1.get_tuto_count(), 1)
def test_get_tutos(self): # Start with 0 self.assertEqual(len(self.user1.get_tutos()), 0) # Create Tuto ! minituto = MiniTutorialFactory() minituto.authors.add(self.user1.user) minituto.gallery = GalleryFactory() minituto.save() # Should be 1 tutos = self.user1.get_tutos() self.assertEqual(len(tutos), 1) self.assertEqual(minituto, tutos[0])
def test_get_beta_tutos(self): # Start with 0 self.assertEqual(len(self.user1.get_beta_tutos()), 0) # Create Tuto ! betatetuto = MiniTutorialFactory() betatetuto.authors.add(self.user1.user) betatetuto.gallery = GalleryFactory() betatetuto.sha_beta = 'whatever' betatetuto.save() # Should be 1 betatetutos = self.user1.get_beta_tutos() self.assertEqual(len(betatetutos), 1) self.assertEqual(betatetuto, betatetutos[0])
def test_get_validate_tutos(self): # Start with 0 self.assertEqual(len(self.user1.get_validate_tutos()), 0) # Create Tuto ! validatetuto = MiniTutorialFactory() validatetuto.authors.add(self.user1.user) validatetuto.gallery = GalleryFactory() validatetuto.sha_validation = 'whatever' validatetuto.save() # Should be 1 validatetutos = self.user1.get_validate_tutos() self.assertEqual(len(validatetutos), 1) self.assertEqual(validatetuto, validatetutos[0])
def test_get_public_tutos(self): # Start with 0 self.assertEqual(len(self.user1.get_public_tutos()), 0) # Create Tuto ! publictuto = MiniTutorialFactory() publictuto.authors.add(self.user1.user) publictuto.gallery = GalleryFactory() publictuto.sha_public = 'whatever' publictuto.save() # Should be 1 publictutos = self.user1.get_public_tutos() self.assertEqual(len(publictutos), 1) self.assertEqual(publictuto, publictutos[0])
def test_migrate_zep12(self): private_mini_tuto = MiniTutorialFactory(title="Private Mini tuto") private_mini_tuto.authors.add(self.user_author) private_mini_tuto.save() multi_author_tuto = MiniTutorialFactory(title="Multi User Tuto") multi_author_tuto.authors.add(self.user_author) multi_author_tuto.authors.add(self.staff) multi_author_tuto.save() public_mini_tuto = PublishedMiniTutorial(title="Public Mini Tuto") public_mini_tuto.authors.add(self.user_author) public_mini_tuto.save() OldTutoValidation( tutorial=public_mini_tuto, version=public_mini_tuto.sha_public, date_proposition=datetime.datetime.now(), comment_authors=u"La vie est belle, le destin s'en écarte.", comment_validator=u"Personne ne joue avec les mêmes cartes.", validator=self.staff, status="ACCEPT", date_reserve=datetime.datetime.now(), date_validation=datetime.datetime.now()).save() staff_note = NoteFactory(tutorial=public_mini_tuto, position=1, author=self.staff) liked_note = NoteFactory(tutorial=public_mini_tuto, position=2, author=self.user_author) t_read = TutorialRead() t_read.tutorial = public_mini_tuto t_read.user = self.staff t_read.note = staff_note t_read.save() like = CommentLike() like.comments = liked_note like.user = self.staff like.save() big_tuto = BigTutorialFactory(title="Big tuto") big_tuto.authors.add(self.user_author) big_tuto.save() public_big_tuto = PublishedBigTutorial(light=False, title="Public Big Tuto") public_big_tuto.authors.add(self.user_author) public_big_tuto.save() private_article = ArticleFactory(title="Private Article") private_article.authors.add(self.user_author) private_article.save() multi_author_article = ArticleFactory(title="Multi Author Article") multi_author_article.authors.add(self.user_author) multi_author_article.authors.add(self.staff) multi_author_article.save() public_article = PublishedArticleFactory(title="Public Article") public_article.authors.add(self.user_author) public_article.save() OldArticleValidation( article=public_article, version=public_article.sha_public, date_proposition=datetime.datetime.now(), comment_authors=u"Pourquoi fortune et infortune?", comment_validator=u"Pourquoi suis-je né les poches vides?", validator=self.staff, status="ACCEPT", date_reserve=datetime.datetime.now(), date_validation=datetime.datetime.now()).save() staff_note = ReactionFactory(article=public_article, position=1, author=self.staff) liked_reaction = ReactionFactory(article=public_article, position=2, author=self.user_author) a_read = ArticleRead() a_read.article = public_article a_read.user = self.staff a_read.reaction = staff_note a_read.save() like = CommentLike() like.comments = liked_reaction like.user = self.staff like.save() category1 = CategoryFactory(position=1) forum11 = ForumFactory(category=category1, position_in_category=1) beta_tuto = BetaMiniTutorialFactory(title=u"Beta Tuto", forum=forum11, author=self.user_author) beta_tuto.authors.add(self.user_author) beta_tuto.save() call_command('migrate_to_zep12') # 1 tuto in setup, 4 mini tutos, 1 big tuto, 3 articles self.assertEqual( PublishableContent.objects.filter( authors__pk__in=[self.user_author.pk]).count(), 10) # if we had n published content we must have 2 * n PublishedContent entities to handle redirections. self.assertEqual( PublishedContent.objects.filter( content__authors__pk__in=[self.user_author.pk]).count(), 2 * 3) self.assertEqual( ContentReaction.objects.filter(author__pk=self.staff.pk).count(), 2) migrated_pulished_article = PublishableContent.objects.filter( authors__in=[self.user_author], title=public_article.title, type="ARTICLE").first() self.assertIsNotNone(migrated_pulished_article) self.assertIsNotNone(migrated_pulished_article.last_note) self.assertEqual( 2, ContentReaction.objects.filter( related_content=migrated_pulished_article).count()) self.assertEqual( 1, ContentRead.objects.filter( content=migrated_pulished_article).count()) self.assertTrue( migrated_pulished_article.is_public( migrated_pulished_article.sha_public)) self.assertTrue( migrated_pulished_article.load_version( migrated_pulished_article.sha_public).has_extracts()) self.assertEqual( len( migrated_pulished_article.load_version( migrated_pulished_article.sha_public).children), 2) migrated_pulished_tuto = PublishableContent.objects.filter( authors__in=[self.user_author], title=public_mini_tuto.title, type="TUTORIAL").first() self.assertIsNotNone(migrated_pulished_tuto) self.assertIsNotNone(migrated_pulished_tuto.last_note) self.assertEqual( 2, ContentReaction.objects.filter( related_content=migrated_pulished_tuto).count()) self.assertEqual( 1, ContentRead.objects.filter(content=migrated_pulished_tuto).count()) self.assertTrue( migrated_pulished_tuto.is_public( migrated_pulished_tuto.sha_public)) beta_content = PublishableContent.objects.filter( title=beta_tuto.title).first() self.assertIsNotNone(beta_content) self.assertEqual(beta_content.sha_beta, beta_tuto.sha_beta) self.assertEqual( Topic.objects.filter(key=beta_tuto.pk).first().pk, beta_content.beta_topic.pk) multi_author_content = PublishableContent.objects.filter(type="TUTORIAL", title=multi_author_tuto.title)\ .first() self.assertIsNotNone(multi_author_content) self.assertEqual(multi_author_content.authors.count(), multi_author_tuto.authors.count()) multi_author_content = PublishableContent.objects.filter(type="ARTICLE", title=multi_author_article.title)\ .first() self.assertIsNotNone(multi_author_content) self.assertEqual(multi_author_content.authors.count(), multi_author_article.authors.count()) old_tutorial_module_prefix = "oldtutoriels" old_article_module_prefix = "oldarticles" new_tutorial_module_prefix = "tutoriels" new_article_module_prefix = "articles" public_article_url = public_article.get_absolute_url_online()\ .replace(old_article_module_prefix, new_article_module_prefix) public_tutorial_url = public_mini_tuto.get_absolute_url_online()\ .replace(old_tutorial_module_prefix, new_tutorial_module_prefix) self.assertEqual(301, self.client.get(public_article_url).status_code) self.assertEqual(301, self.client.get(public_tutorial_url).status_code) public_chapter = Chapter.objects.filter( part__tutorial__pk=public_big_tuto.pk).first() self.assertIsNotNone(public_chapter) public_chapter_url = public_chapter.get_absolute_url_online() public_chapter_url = public_chapter_url.replace( old_tutorial_module_prefix, new_tutorial_module_prefix) self.assertEqual(301, self.client.get(public_chapter_url).status_code) self.assertEqual( 200, self.client.get(public_chapter_url, follow=True).status_code) self.assertEqual( 200, self.client.get(public_article_url, follow=True).status_code) self.assertEqual( 200, self.client.get(public_tutorial_url, follow=True).status_code) tuto_validation = Validation.objects.filter( content__pk=migrated_pulished_tuto.pk).first() self.assertIsNotNone(tuto_validation) self.assertEqual(tuto_validation.status, "ACCEPT") self.assertEqual(tuto_validation.validator.pk, self.staff.pk) article_validation = Validation.objects.filter( content__pk=migrated_pulished_article.pk).first() self.assertIsNotNone(article_validation) self.assertEqual(article_validation.status, "ACCEPT") self.assertEqual(article_validation.validator.pk, self.staff.pk)
def test_unregister(self): """Tests that unregistering user is working""" # test not logged user can't unregister self.client.logout() result = self.client.post(reverse('zds.member.views.unregister'), follow=False) self.assertEqual(result.status_code, 302) user = ProfileFactory() login_check = self.client.login(username=user.user.username, password='******') self.assertEqual(login_check, True) result = self.client.post(reverse('zds.member.views.unregister'), follow=False) self.assertEqual(result.status_code, 302) self.assertEqual( User.objects.filter(username=user.user.username).count(), 0) user = ProfileFactory() user2 = ProfileFactory() aloneGallery = GalleryFactory() UserGalleryFactory(gallery=aloneGallery, user=user.user) sharedGallery = GalleryFactory() UserGalleryFactory(gallery=sharedGallery, user=user.user) UserGalleryFactory(gallery=sharedGallery, user=user2.user) # first case : a published tutorial with only one author publishedTutorialAlone = MiniTutorialFactory(light=True) publishedTutorialAlone.authors.add(user.user) publishedTutorialAlone.save() # second case : a published tutorial with two authors publishedTutorial2 = MiniTutorialFactory(light=True) publishedTutorial2.authors.add(user.user) publishedTutorial2.authors.add(user2.user) publishedTutorial2.save() # third case : a private tutorial with only one author writingTutorialAlone = MiniTutorialFactory(light=True) writingTutorialAlone.authors.add(user.user) writingTutorialAlone.save() writingTutorialAloneGallerPath = writingTutorialAlone.gallery.get_gallery_path( ) writingTutorialAlonePath = writingTutorialAlone.get_path() # fourth case : a private tutorial with at least two authors writingTutorial2 = MiniTutorialFactory(light=True) writingTutorial2.authors.add(user.user) writingTutorial2.authors.add(user2.user) writingTutorial2.save() self.client.login(username=self.staff.username, password="******") pub = self.client.post(reverse('zds.tutorial.views.ask_validation'), { 'tutorial': publishedTutorialAlone.pk, 'text': u'Ce tuto est excellent', 'version': publishedTutorialAlone.sha_draft, 'source': 'http://zestedesavoir.com', }, follow=False) self.assertEqual(pub.status_code, 302) # reserve tutorial validation = Validation.objects.get( tutorial__pk=publishedTutorialAlone.pk) pub = self.client.post(reverse('zds.tutorial.views.reservation', args=[validation.pk]), follow=False) self.assertEqual(pub.status_code, 302) # publish tutorial pub = self.client.post(reverse('zds.tutorial.views.valid_tutorial'), { 'tutorial': publishedTutorialAlone.pk, 'text': u'Ce tuto est excellent', 'is_major': True, 'source': 'http://zestedesavoir.com', }, follow=False) pub = self.client.post(reverse('zds.tutorial.views.ask_validation'), { 'tutorial': publishedTutorial2.pk, 'text': u'Ce tuto est excellent', 'version': publishedTutorial2.sha_draft, 'source': 'http://zestedesavoir.com', }, follow=False) self.assertEqual(pub.status_code, 302) # reserve tutorial validation = Validation.objects.get(tutorial__pk=publishedTutorial2.pk) pub = self.client.post(reverse('zds.tutorial.views.reservation', args=[validation.pk]), follow=False) self.assertEqual(pub.status_code, 302) # publish tutorial pub = self.client.post(reverse('zds.tutorial.views.valid_tutorial'), { 'tutorial': publishedTutorial2.pk, 'text': u'Ce tuto est excellent', 'is_major': True, 'source': 'http://zestedesavoir.com', }, follow=False) # same thing for articles publishedArticleAlone = ArticleFactory() publishedArticleAlone.authors.add(user.user) publishedArticleAlone.save() publishedArticle2 = ArticleFactory() publishedArticle2.authors.add(user.user) publishedArticle2.authors.add(user2.user) publishedArticle2.save() writingArticleAlone = ArticleFactory() writingArticleAlone.authors.add(user.user) writingArticleAlone.save() writingArticle2 = ArticleFactory() writingArticle2.authors.add(user.user) writingArticle2.authors.add(user2.user) writingArticle2.save() # ask public article pub = self.client.post(reverse('zds.article.views.modify'), { 'article': publishedArticleAlone.pk, 'comment': u'Valides moi ce bébé', 'pending': 'Demander validation', 'version': publishedArticleAlone.sha_draft, 'is_major': True }, follow=False) self.assertEqual(pub.status_code, 302) login_check = self.client.login(username=self.staff.username, password='******') self.assertEqual(login_check, True) # reserve article validation = ArticleValidation.objects.get( article__pk=publishedArticleAlone.pk) pub = self.client.post(reverse('zds.article.views.reservation', args=[validation.pk]), follow=False) self.assertEqual(pub.status_code, 302) # publish article pub = self.client.post(reverse('zds.article.views.modify'), { 'article': publishedArticleAlone.pk, 'comment-v': u'Cet article est excellent', 'valid-article': 'Demander validation', 'is_major': True }, follow=False) self.assertEqual(pub.status_code, 302) # ask public article pub = self.client.post(reverse('zds.article.views.modify'), { 'article': publishedArticle2.pk, 'comment': u'Valides moi ce bébé', 'pending': 'Demander validation', 'version': publishedArticle2.sha_draft, 'is_major': True }, follow=False) self.assertEqual(pub.status_code, 302) login_check = self.client.login(username=self.staff.username, password='******') self.assertEqual(login_check, True) # reserve article validation = ArticleValidation.objects.get( article__pk=publishedArticle2.pk) pub = self.client.post(reverse('zds.article.views.reservation', args=[validation.pk]), follow=False) self.assertEqual(pub.status_code, 302) # publish article pub = self.client.post(reverse('zds.article.views.modify'), { 'article': publishedArticle2.pk, 'comment-v': u'Cet article est excellent', 'valid-article': 'Demander validation', 'is_major': True }, follow=False) self.assertEqual(pub.status_code, 302) # about posts and topics authoredTopic = TopicFactory(author=user.user, forum=self.forum11) answeredTopic = TopicFactory(author=user2.user, forum=self.forum11) PostFactory(topic=answeredTopic, author=user.user, position=2) editedAnswer = PostFactory(topic=answeredTopic, author=user.user, position=3) editedAnswer.editor = user.user editedAnswer.save() privateTopic = PrivateTopicFactory(author=user.user) privateTopic.participants.add(user2.user) privateTopic.save() PrivatePostFactory(author=user.user, privatetopic=privateTopic, position_in_topic=1) login_check = self.client.login(username=user.user.username, password='******') self.assertEqual(login_check, True) result = self.client.post(reverse('zds.member.views.unregister'), follow=False) self.assertEqual(result.status_code, 302) self.assertEqual(publishedTutorialAlone.authors.count(), 1) self.assertEqual(publishedTutorialAlone.authors.first().username, settings.ZDS_APP["member"]["external_account"]) self.assertFalse(os.path.exists(writingTutorialAloneGallerPath)) self.assertEqual(publishedTutorial2.authors.count(), 1) self.assertEqual( publishedTutorial2.authors.filter( username=settings.ZDS_APP["member"] ["external_account"]).count(), 0) self.assertIsNotNone(publishedTutorial2.get_prod_path()) self.assertTrue(os.path.exists(publishedTutorial2.get_prod_path())) self.assertIsNotNone(publishedTutorialAlone.get_prod_path()) self.assertTrue(os.path.exists(publishedTutorialAlone.get_prod_path())) self.assertEqual( self.client.get(reverse( 'zds.tutorial.views.view_tutorial_online', args=[publishedTutorialAlone.pk, publishedTutorialAlone.slug]), follow=False).status_code, 200) self.assertEqual( self.client.get(reverse( 'zds.tutorial.views.view_tutorial_online', args=[publishedTutorial2.pk, publishedTutorial2.slug]), follow=False).status_code, 200) self.assertTrue(os.path.exists(publishedArticleAlone.get_path())) self.assertEqual( self.client.get(reverse( 'zds.article.views.view_online', args=[publishedArticleAlone.pk, publishedArticleAlone.slug]), follow=True).status_code, 200) self.assertEqual( self.client.get(reverse( 'zds.article.views.view_online', args=[publishedArticle2.pk, publishedArticle2.slug]), follow=True).status_code, 200) self.assertEqual( Tutorial.objects.filter(pk=writingTutorialAlone.pk).count(), 0) self.assertEqual(writingTutorial2.authors.count(), 1) self.assertEqual( writingTutorial2.authors.filter(username=settings.ZDS_APP["member"] ["external_account"]).count(), 0) self.assertEqual(publishedArticleAlone.authors.count(), 1) self.assertEqual(publishedArticleAlone.authors.first().username, settings.ZDS_APP["member"]["external_account"]) self.assertEqual(publishedArticle2.authors.count(), 1) self.assertEqual( publishedArticle2.authors.filter( username=settings.ZDS_APP["member"] ["external_account"]).count(), 0) self.assertEqual( Article.objects.filter(pk=writingArticleAlone.pk).count(), 0) self.assertEqual(writingArticle2.authors.count(), 1) self.assertEqual( writingArticle2.authors.filter(username=settings.ZDS_APP["member"] ["external_account"]).count(), 0) self.assertEqual( Topic.objects.filter(author__username=user.user.username).count(), 0) self.assertEqual( Post.objects.filter(author__username=user.user.username).count(), 0) self.assertEqual( Post.objects.filter(editor__username=user.user.username).count(), 0) self.assertEqual( PrivatePost.objects.filter( author__username=user.user.username).count(), 0) self.assertEqual( PrivateTopic.objects.filter( author__username=user.user.username).count(), 0) self.assertFalse(os.path.exists(writingTutorialAlonePath)) self.assertIsNotNone(Topic.objects.get(pk=authoredTopic.pk)) self.assertIsNotNone(PrivateTopic.objects.get(pk=privateTopic.pk)) self.assertIsNotNone(Gallery.objects.get(pk=aloneGallery.pk)) self.assertEquals(aloneGallery.get_users().count(), 1) self.assertEquals(sharedGallery.get_users().count(), 1) self.assertEquals( UserGallery.objects.filter(user=user.user).count(), 0)
class LastTutorialsFeedRSSTest(TestCase): def setUp(self): settings.EMAIL_BACKEND = \ 'django.core.mail.backends.locmem.EmailBackend' self.mas = ProfileFactory().user settings.ZDS_APP['member']['bot_account'] = self.mas.username self.user_author = ProfileFactory().user self.user = ProfileFactory().user self.staff = StaffProfileFactory().user self.subcat = SubCategoryFactory() self.licence = LicenceFactory() self.licence.save() self.minituto = MiniTutorialFactory() self.minituto.authors.add(self.user_author) self.minituto.gallery = GalleryFactory() self.minituto.licence = self.licence self.minituto.save() self.chapter = ChapterFactory( tutorial=self.minituto, position_in_tutorial=1) self.staff = StaffProfileFactory().user login_check = self.client.login( username=self.staff.username, password='******') self.assertEqual(login_check, True) # ask public tutorial pub = self.client.post( reverse('zds.tutorial.views.ask_validation'), { 'tutorial': self.minituto.pk, 'text': u'Ce tuto est excellent', 'version': self.minituto.sha_draft, 'source': 'http://zestedesavoir.com', }, follow=False) self.assertEqual(pub.status_code, 302) # reserve tutorial validation = Validation.objects.get( tutorial__pk=self.minituto.pk) pub = self.client.post( reverse('zds.tutorial.views.reservation', args=[validation.pk]), follow=False) self.assertEqual(pub.status_code, 302) # publish tutorial pub = self.client.post( reverse('zds.tutorial.views.valid_tutorial'), { 'tutorial': self.minituto.pk, 'text': u'Ce tuto est excellent', 'is_major': True, 'source': 'http://zestedesavoir.com', }, follow=False) self.assertEqual(pub.status_code, 302) self.minituto = Tutorial.objects.get(pk=self.minituto.pk) self.assertEqual(self.minituto.on_line(), True) self.assertEquals(len(mail.outbox), 1) mail.outbox = [] self.tutofeed = LastTutorialsFeedRSS() def test_is_well_setup(self): """ Test that base parameters are Ok """ self.assertEqual(self.tutofeed.link, '/tutoriels/') reftitle = u"Tutoriels sur {}".format(settings.ZDS_APP['site']['litteral_name']) self.assertEqual(self.tutofeed.title, reftitle) refdescription = u"Les derniers tutoriels parus sur {}.".format(settings.ZDS_APP['site']['litteral_name']) self.assertEqual(self.tutofeed.description, refdescription) atom = LastTutorialsFeedATOM() self.assertEqual(atom.subtitle, refdescription) def test_get_items(self): """ basic test sending back the tutorial """ ret = self.tutofeed.items() self.assertEqual(ret[0], self.minituto) def test_get_pubdate(self): """ test the return value of pubdate """ ref = Tutorial.objects.get(pk=self.minituto.pk).pubdate tuto = self.tutofeed.items()[0] ret = self.tutofeed.item_pubdate(item=tuto) self.assertEqual(ret.date(), ref.date()) def test_get_title(self): """ test the return value of title """ ref = self.minituto.title tuto = self.tutofeed.items()[0] ret = self.tutofeed.item_title(item=tuto) self.assertEqual(ret, ref) def test_get_description(self): """ test the return value of description """ ref = self.minituto.description tuto = self.tutofeed.items()[0] ret = self.tutofeed.item_description(item=tuto) self.assertEqual(ret, ref) def test_get_author_name(self): """ test the return value of author name """ ref = self.user_author.username tuto = self.tutofeed.items()[0] ret = self.tutofeed.item_author_name(item=tuto) self.assertEqual(ret, ref) def test_get_item_link(self): """ test the return value of item link """ ref = self.minituto.get_absolute_url_online() tuto = self.tutofeed.items()[0] ret = self.tutofeed.item_link(item=tuto) self.assertEqual(ret, ref) def tearDown(self): if os.path.isdir(settings.ZDS_APP['tutorial']['repo_path']): shutil.rmtree(settings.ZDS_APP['tutorial']['repo_path']) if os.path.isdir(settings.ZDS_APP['tutorial']['repo_public_path']): shutil.rmtree(settings.ZDS_APP['tutorial']['repo_public_path']) if os.path.isdir(settings.MEDIA_ROOT): shutil.rmtree(settings.MEDIA_ROOT)