tests: adjust tests after email changes.

rhodecode/tests/functional/test_changeset_comments.py

@@ -1,231 +1,237 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from pylons.i18n import ungettext
 import pytest
 
 from rhodecode.tests import *
 from rhodecode.model.db import (
     ChangesetComment, Notification, UserNotification)
 from rhodecode.model.meta import Session
+from rhodecode.lib import helpers as h
 
 
 @pytest.mark.backends("git", "hg", "svn")
 class TestChangeSetCommentsController(TestController):
 
     @pytest.fixture(autouse=True)
     def prepare(self, request, pylonsapp):
         for x in ChangesetComment.query().all():
             Session().delete(x)
         Session().commit()
 
         for x in Notification.query().all():
             Session().delete(x)
         Session().commit()
 
         request.addfinalizer(self.cleanup)
 
     def cleanup(self):
         for x in ChangesetComment.query().all():
             Session().delete(x)
         Session().commit()
 
         for x in Notification.query().all():
             Session().delete(x)
         Session().commit()
 
     def test_create(self, backend):
         self.log_user()
-        commit_id = backend.repo.get_commit('300').raw_id
+        commit = backend.repo.get_commit('300')
+        commit_id = commit.raw_id
         text = u'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             url(controller='changeset', action='comment',
                 repo_name=backend.repo_name, revision=commit_id), params=params)
 
         response = self.app.get(
             url(controller='changeset', action='index',
                 repo_name=backend.repo_name, revision=commit_id))
 
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, ChangesetComment.query().count(), 0)
 
         assert Notification.query().count() == 1
         assert ChangesetComment.query().count() == 1
 
         notification = Notification.query().all()[0]
 
         comment_id = ChangesetComment.query().first().comment_id
         assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
 
-        sbj = 'commented on a commit of {0}'.format(backend.repo_name)
+        sbj = 'commented on commit `{0}` in the {1} repository'.format(
+            h.show_id(commit), backend.repo_name)
         assert sbj in notification.subject
 
         lnk = (u'/{0}/changeset/{1}#comment-{2}'.format(
             backend.repo_name, commit_id, comment_id))
         assert lnk in notification.body
 
     def test_create_inline(self, backend):
         self.log_user()
-        commit_id = backend.repo.get_commit('300').raw_id
+        commit = backend.repo.get_commit('300')
+        commit_id = commit.raw_id
         text = u'CommentOnCommit'
         f_path = 'vcs/web/simplevcs/views/repository.py'
         line = 'n1'
 
         params = {'text': text, 'f_path': f_path, 'line': line,
                   'csrf_token': self.csrf_token}
 
         self.app.post(
             url(controller='changeset', action='comment',
                 repo_name=backend.repo_name, revision=commit_id), params=params)
 
         response = self.app.get(
             url(controller='changeset', action='index',
                 repo_name=backend.repo_name, revision=commit_id))
 
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, 0, ChangesetComment.query().count())
         response.mustcontain(
             '''class="inline-comment-placeholder" '''
             '''path="vcs/web/simplevcs/views/repository.py" '''
             '''target_id="vcswebsimplevcsviewsrepositorypy"'''
         )
 
         assert Notification.query().count() == 1
         assert ChangesetComment.query().count() == 1
 
         notification = Notification.query().all()[0]
         comment = ChangesetComment.query().first()
         assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
 
         assert comment.revision == commit_id
-
-        sbj = ' commented on a commit of {0}'.format(backend.repo_name)
+        sbj = 'commented on commit `{commit}` ' \
+              '(file: `{f_path}`) in the {repo} repository'.format(
+            commit=h.show_id(commit),
+            f_path=f_path, line=line, repo=backend.repo_name)
         assert sbj in notification.subject
 
         lnk = (u'/{0}/changeset/{1}#comment-{2}'.format(
             backend.repo_name, commit_id, comment.comment_id))
         assert lnk in notification.body
         assert 'on line n1' in notification.body
 
     def test_create_with_mention(self, backend):
         self.log_user()
 
         commit_id = backend.repo.get_commit('300').raw_id
         text = u'@test_regular check CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             url(controller='changeset', action='comment',
                 repo_name=backend.repo_name, revision=commit_id), params=params)
 
         response = self.app.get(
             url(controller='changeset', action='index',
                 repo_name=backend.repo_name, revision=commit_id))
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, ChangesetComment.query().count(), 0)
 
         notification = Notification.query().one()
 
         assert len(notification.recipients) == 2
         users = [x.username for x in notification.recipients]
 
         # test_regular gets notification by @mention
         assert sorted(users) == [u'test_admin', u'test_regular']
 
     def test_delete(self, backend):
         self.log_user()
         commit_id = backend.repo.get_commit('300').raw_id
         text = u'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             url(
                 controller='changeset', action='comment',
                 repo_name=backend.repo_name, revision=commit_id),
             params=params)
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 1
         comment_id = comments[0].comment_id
 
         self.app.post(
             url(controller='changeset', action='delete_comment',
                 repo_name=backend.repo_name, comment_id=comment_id),
             params={'_method': 'delete', 'csrf_token': self.csrf_token})
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 0
 
         response = self.app.get(
             url(controller='changeset', action='index',
                 repo_name=backend.repo_name, revision=commit_id))
         assert_comment_links(response, 0, 0)
 
     @pytest.mark.parametrize('renderer, input, output', [
         ('rst', 'plain text', '<p>plain text</p>'),
         ('rst', 'header\n======', '<h1 class="title">header</h1>'),
         ('rst', '*italics*', '<em>italics</em>'),
         ('rst', '**bold**', '<strong>bold</strong>'),
         ('markdown', 'plain text', '<p>plain text</p>'),
         ('markdown', '# header', '<h1>header</h1>'),
         ('markdown', '*italics*', '<em>italics</em>'),
         ('markdown', '**bold**', '<strong>bold</strong>'),
     ])
     def test_preview(self, renderer, input, output, backend):
         self.log_user()
         params = {
             'renderer': renderer,
             'text': input,
             'csrf_token': self.csrf_token
         }
         environ = {
             'HTTP_X_PARTIAL_XHR': 'true'
         }
         response = self.app.post(
             url(controller='changeset',
                 action='preview_comment',
                 repo_name=backend.repo_name),
             params=params,
             extra_environ=environ)
 
         response.mustcontain(output)
 
 
 def assert_comment_links(response, comments, inline_comments):
     comments_text = ungettext("%d Commit comment",
                               "%d Commit comments", comments) % comments
     if comments:
         response.mustcontain('<a href="#comments">%s</a>,' % comments_text)
     else:
         response.mustcontain(comments_text)
 
     inline_comments_text = ungettext("%d Inline Comment", "%d Inline Comments",
                                      inline_comments) % inline_comments
     if inline_comments:
         response.mustcontain(
             '<a href="#inline-comments" '
             'id="inline-comments-counter">%s</a>' % inline_comments_text)
     else:
         response.mustcontain(inline_comments_text)