1825,3,demo,357,firs,"",user_created_repo,2012-11-04 00:37:08.700977

1826,316,theo,358,brightandshiny,"",started_following_repo,2012-11-04 14:17:04.270938

1827,316,theo,358,brightandshiny,"",user_created_repo,2012-11-04 14:17:04.286049

1828,316,theo,358,brightandshiny,87.165.13.203,"push:831fd48093c38f64bb541a4c12bec45d27c13f9d,0177264991ad113c2dbeed00716738931bc0222f",2012-11-04 14:21:33.759458

1829,3,demo,45,group/fork-bootstrap,"",started_following_repo,2012-11-04 18:25:45.459487

1830,3,demo,45,group/fork-bootstrap,"",stopped_following_repo,2012-11-04 18:25:48.166886

1831,3,demo,45,group/fork-bootstrap,"",started_following_repo,2012-11-04 18:25:51.905362

1832,3,demo,45,group/fork-bootstrap,"",stopped_following_repo,2012-11-04 18:25:54.406445

1833,3,demo,227,fork-aaa-project-2,"",user_commented_revision:bc829c34912709c7d129e5dae9a3e5ff46e77fc7,2012-11-05 18:37:48.772572

1834,3,demo,227,fork-aaa-project-2,"",user_commented_revision:bc829c34912709c7d129e5dae9a3e5ff46e77fc7,2012-11-05 18:38:42.521316

1835,3,demo,359,MyUberRepo,"",started_following_repo,2012-11-05 22:04:02.939575

1836,3,demo,359,MyUberRepo,"",user_created_repo,2012-11-05 22:04:02.95609

1837,3,demo,359,MyUberRepo,"",push_local:a67ddbdca6d533e0cd43175068cc12f526b2f95f,2012-11-05 22:07:40.846096

1838,3,demo,360,marese_test,"",started_following_repo,2012-11-05 22:10:35.535744

1839,3,demo,360,marese_test,"",user_created_repo,2012-11-05 22:10:35.547878

1840,3,demo,361,test-23,"",started_following_repo,2012-11-06 04:01:46.385817

1841,3,demo,361,test-23,"",user_created_repo,2012-11-06 04:01:46.410423

1842,3,demo,361,test-23,"",push_local:7d8547b154a01c7055a09292e871e80f3c6b574b,2012-11-06 04:03:03.320736

1843,3,demo,361,test-23,"",user_commented_revision:7d8547b154a01c7055a09292e871e80f3c6b574b,2012-11-06 04:07:20.51212

1844,3,demo,99,another-fork-to-check-code-review,"",user_commented_revision:fba17a64fa4978bfea19222da5e64a18cfddeecd,2012-11-06 04:12:51.753053

1845,3,demo,99,another-fork-to-check-code-review,"",user_commented_revision:fba17a64fa4978bfea19222da5e64a18cfddeecd,2012-11-06 04:13:30.727101

1846,3,demo,99,another-fork-to-check-code-review,"",user_commented_revision:fba17a64fa4978bfea19222da5e64a18cfddeecd,2012-11-06 04:15:29.032768

1847,3,demo,68,aaa-project,"",user_commented_revision:0c33fa58efc5a5541d8d3f1a3d3b77367e3d94f5,2012-11-06 04:17:16.091927

1848,3,demo,249,abcdefg,"",user_commented_revision:5d80e28538141e322b317168e2367fb03178d58c,2012-11-06 06:10:53.372505

1852,3,demo,177,blah,62.200.22.2,push:b369fb18c8d61fe0d3b14c417466680230cabe46,2012-11-06 10:47:55.655029

1853,3,demo,99,another-fork-to-check-code-review,"",user_commented_revision:d5422faf648cc589425cd3b0dbf1f6dbf93036a0,2012-11-06 13:12:05.517155

1854,3,demo,38,code-review-test,"",user_commented_revision:6d7db5794e8cad7da042b6ae6238116c6e59a4d2,2012-11-06 16:12:59.38977

1855,3,demo,363,utf8-test,"",started_following_repo,2012-11-06 16:52:34.020264

1856,3,demo,363,utf8-test,"",user_created_repo,2012-11-06 16:52:34.036171

1857,3,demo,363,utf8-test,178.6.80.143,push:e9e69068b8277c8e857984fb44e54d4e057710bd,2012-11-06 16:54:30.357337

1858,320,blahblub,364,abc_test,"",started_following_repo,2012-11-06 22:06:45.476725

1859,320,blahblub,364,abc_test,"",user_created_repo,2012-11-06 22:06:45.488546

1860,320,blahblub,364,abc_test,81.190.220.154,"push:e05d82d631f4a61972c2c76eb5b473c55ee6133f,dccf54ebc0638183872cfd9d35f0f49aa44ad4bc",2012-11-06 22:07:39.657839

1861,320,blahblub,364,abc_test,81.190.220.154,push:8ef2f06b68eb25067c4ca3a9c73c89bb681f031b,2012-11-06 22:09:18.572762

1862,3,demo,365,testing_do,"",started_following_repo,2012-11-07 00:19:56.15291

1863,3,demo,365,testing_do,"",user_created_repo,2012-11-07 00:19:56.165626

1864,3,demo,365,testing_do,"",user_updated_repo,2012-11-07 00:21:24.482025

1865,3,demo,321,Mecurial-Test,"",user_commented_revision:041e48fd7acad4c27385c27a4789d3d5cc7ccbea,2012-11-07 01:16:37.129361

1866,321,ifco89,284,fork-django,"",user_commented_revision:129f1ac8484d63c2e61a44fb2a18dd17246c1c4d,2012-11-07 01:26:40.887017

1867,3,demo,284,fork-django,"",user_commented_revision:c5d6f6d6829e730bdddf63c1252304f0c49a9053,2012-11-07 01:27:33.995596

1868,3,demo,68,aaa-project,"",push_local:5ecd97456233badb3680873dc5b7d4bfb52ede79,2012-11-07 06:43:22.378406

1869,3,demo,319,fork1-code-review-test,"",user_commented_revision:e216971a777e3132487405dd2c8e093f66788765,2012-11-07 08:44:19.419642

1870,3,demo,366,test123123,"",started_following_repo,2012-11-07 14:16:13.029479

1871,3,demo,366,test123123,"",user_created_repo,2012-11-07 14:16:13.04346

1872,323,didi,364,abc_test,"",user_commented_revision:8ef2f06b68eb25067c4ca3a9c73c89bb681f031b,2012-11-07 15:45:10.378961

1873,324,tutty,367,fork-bootstrap,"",started_following_repo,2012-11-07 16:00:47.116111

1874,324,tutty,36,bootstrap,"",user_forked_repo:fork-bootstrap,2012-11-07 16:00:48.378051

1875,324,tutty,367,fork-bootstrap,"",user_created_fork:fork-bootstrap,2012-11-07 16:00:48.393002

                                        {'username': 'xxxaxn',

                                         'password': 'ąćźżąśśśś',

                                         'password_confirmation': 'ąćźżąśśśś',

                                         'email': 'goodmailm@test.plx',

                                         'firstname': 'test',

                                         'lastname': 'test'})

        msg = validators.ValidPassword()._messages['invalid_password']

        response.mustcontain(msg)

    def test_register_password_mismatch(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username': 'xs',

                                             'password': '123qwe',

                                             'password_confirmation': 'qwe123',

                                             'email': 'goodmailm@test.plxa',

                                             'firstname': 'test',

                                             'lastname': 'test'})

        msg = validators.ValidPasswordsMatch()._messages['password_mismatch']

        response.mustcontain(msg)

    def test_register_ok(self):

        username = 'test_regular4'

        password = 'qweqwe'

        name = 'testname'

        lastname = 'testlastname'

        response = self.app.post(url(controller='login', action='register'),

                                            {'username': username,

                                             'password': password,

                                             'password_confirmation': password,

                                             'email': email,

                                             'firstname': name,

                                             'lastname': lastname,

                                             'admin': True})  # This should be overriden

        self.assertEqual(response.status, '302 Found')

        self.checkSessionFlash(response, 'You have successfully registered into Kallithea')

        ret = Session().query(User).filter(User.username == 'test_regular4').one()

        self.assertEqual(ret.username, username)

        self.assertEqual(check_password(password, ret.password), True)

        self.assertEqual(ret.email, email)

        self.assertEqual(ret.name, name)

        self.assertEqual(ret.lastname, lastname)

        self.assertNotEqual(ret.api_key, None)

        self.assertEqual(ret.admin, False)

    def test_forgot_password_wrong_mail(self):

        response = self.app.post(

                        url(controller='login', action='password_reset'),

                            {'email': bad_email, }

        )

        msg = validators.ValidSystemEmail()._messages['non_existing_email']

        msg = h.html_escape(msg % {'email': bad_email})

        response.mustcontain()

    def test_forgot_password(self):

        response = self.app.get(url(controller='login',

                                    action='password_reset'))

        self.assertEqual(response.status, '200 OK')

        username = 'test_password_reset_1'

        password = 'qweqwe'

        name = 'passwd'

        lastname = 'reset'

        new = User()

        new.username = username

        new.password = password

        new.email = email

        new.name = name

        new.lastname = lastname

        new.api_key = generate_api_key(username)

        Session().add(new)

        Session().commit()

        response = self.app.post(url(controller='login',

                                     action='password_reset'),

                                 {'email': email, })

        self.checkSessionFlash(response, 'Your password reset link was sent')

        response = response.follow()

        # BAD KEY

        key = "bad"

        _url = 'http://%(user)s:%(passwd)s@%(host)s/%(cloned_repo)s %(dest)s' % params

    else:

        _url = 'http://(host)s/%(cloned_repo)s %(dest)s' % params

    return _url

def _add_files_and_push(vcs, DEST, **kwargs):

    """

    Generate some files, add it to DEST repo and push back

    vcs is git or hg and defines what VCS we want to make those files for

    :param vcs:

    :param DEST:

    """

    # commit some stuff into this repo

    cwd = path = jn(DEST)

    #added_file = jn(path, '%ssetupążźć.py' % _RandomNameSequence().next())

    added_file = jn(path, '%ssetup.py' % _RandomNameSequence().next())

    Command(cwd).execute('touch %s' % added_file)

    Command(cwd).execute('%s add %s' % (vcs, added_file))

    for i in xrange(kwargs.get('files_no', 3)):

        cmd = """echo 'added_line%s' >> %s""" % (i, added_file)

        Command(cwd).execute(cmd)

        if vcs == 'hg':

            cmd = """hg commit -m 'commited new %s' -u '%s' %s """ % (

                i, author_str, added_file

            )

        elif vcs == 'git':

            cmd = """EMAIL="me@email.com" git commit -m 'commited new %s' --author '%s' %s """ % (

                i, author_str, added_file

            )

        Command(cwd).execute(cmd)

    # PUSH it back

    _REPO = None

    if vcs == 'hg':

        _REPO = HG_REPO

    elif vcs == 'git':

        _REPO = GIT_REPO

    kwargs['dest'] = ''

    clone_url = _construct_url(_REPO, **kwargs)

    if 'clone_url' in kwargs:

        clone_url = kwargs['clone_url']

    stdout = stderr = None

    if vcs == 'hg':

        stdout, stderr = Command(cwd).execute('hg push --verbose', clone_url)

~~~~~~~~~~~~~~~~~~~~~~~~~

Package for testing various lib/helper functions in kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jun 9, 2011

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

from __future__ import with_statement

import datetime

import hashlib

import mock

from kallithea.tests import *

from kallithea.lib.utils2 import AttributeDict

from kallithea.model.db import Repository

proto = 'http'

TEST_URLS = [

    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

     '%s://127.0.0.1' % proto),

     '%s://127.0.0.1' % proto),

    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

     '%s://127.0.0.1:8080' % proto),

    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

     '%s://domain.org' % proto),

    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

                                                '8080'],

     '%s://domain.org:8080' % proto),

]

proto = 'https'

TEST_URLS += [

    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

     '%s://127.0.0.1' % proto),

     '%s://127.0.0.1' % proto),

     '%s://127.0.0.1' % proto),

    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

     '%s://127.0.0.1:8080' % proto),

    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

     '%s://domain.org' % proto),

    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

                                                '8080'],

     '%s://domain.org:8080' % proto),

]

class TestLibs(BaseTestCase):

    @parameterized.expand(TEST_URLS)

    def test_uri_filter(self, test_url, expected, expected_creds):

        from kallithea.lib.utils2 import uri_filter

        self.assertEqual(uri_filter(test_url), expected)

    @parameterized.expand(TEST_URLS)

    def test_credentials_filter(self, test_url, expected, expected_creds):

        from kallithea.lib.utils2 import credentials_filter

        self.assertEqual(credentials_filter(test_url), expected_creds)

    @parameterized.expand([('t', True),

                           ('true', True),

                           ('y', True),

                           ('yes', True),

                           ('on', True),

                           ('1', True),

                           ('Y', True),

                           ('yeS', True),

                           ('Y', True),

                           ('TRUE', True),

                           ('T', True),

                           ('False', False),

                           ('F', False),

                           ('FALSE', False),

                           ('0', False),

                           ('-1', False),

                           ('', False)

    ])

    def test_str2bool(self, str_bool, expected):

        from kallithea.lib.utils2 import str2bool

        self.assertEqual(str2bool(str_bool), expected)

    def test_mention_extractor(self):

        from kallithea.lib.utils2 import extract_mentioned_users

        sample = (

            "@lukaszb check @one_more22 it pls @ ttwelve @D[] @one@two@three "

            "@marian.user just do it @marco-polo and next extract @marco_polo "

            "user.dot  hej ! not-needed maril@domain.org"

        )

        s = sorted([

        self.assertEqual(s, extract_mentioned_users(sample))

    @parameterized.expand([

        (dict(), u'just now'),

        (dict(seconds= -1), u'1 second ago'),

        (dict(seconds= -60 * 2), u'2 minutes ago'),

        (dict(hours= -1), u'1 hour ago'),

        (dict(hours= -24), u'1 day ago'),

        (dict(hours= -24 * 5), u'5 days ago'),

        (dict(months= -1), u'1 month ago'),

        (dict(months= -1, days= -2), u'1 month and 2 days ago'),

        (dict(months= -1, days= -20), u'1 month and 19 days ago'),

        (dict(years= -1, months= -1), u'1 year and 1 month ago'),

        (dict(years= -1, months= -10), u'1 year and 10 months ago'),

        (dict(years= -2, months= -4), u'2 years and 4 months ago'),

        (dict(years= -2, months= -11), u'2 years and 11 months ago'),

        (dict(years= -3, months= -2), u'3 years and 2 months ago'),

    ])

    def test_age(self, age_args, expected):

        from kallithea.lib.utils2 import age

        from dateutil import relativedelta

        n = datetime.datetime(year=2012, month=5, day=17)

        delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

        self.assertEqual(age(n + delt(**age_args), now=n), expected)

            with mock.patch('pylons.tmpl_context', fake):

                grav = gravatar_url(email_address='test@foo.com', size=24)

                assert grav == 'http://test.com/test@foo.com'

            fake = fake_tmpl_context(_url='http://test.com/{md5email}')

            with mock.patch('pylons.tmpl_context', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://test.com/%s' % (_md5(em))

            fake = fake_tmpl_context(_url='http://test.com/{md5email}/{size}')

            with mock.patch('pylons.tmpl_context', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'http://test.com/%s/%s' % (_md5(em), 24)

            fake = fake_tmpl_context(_url='{scheme}://{netloc}/{md5email}/{size}')

            with mock.patch('pylons.tmpl_context', fake):

                em = 'test@foo.com'

                grav = gravatar_url(email_address=em, size=24)

                assert grav == 'https://server.com/%s/%s' % (_md5(em), 24)

    @parameterized.expand([

        (Repository.DEFAULT_CLONE_URI, 'group/repo1', {}, '', 'http://vps1:8000/group/repo1'),

        ('{scheme}://{user}@{netloc}/_{repoid}', 'group/repo1', {}, '', 'http://vps1:8000/_23'),

        ('https://{user}@proxy1.server.com/{repo}', 'group/repo1', {}, '', 'https://proxy1.server.com/group/repo1'),

    ])

    def test_clone_url_generator(self, tmpl, repo_name, overrides, prefix, expected):

        from kallithea.lib.utils2 import get_clone_url

        clone_url = get_clone_url(uri_tmpl=tmpl, qualifed_home_url='http://vps1:8000'+prefix,

                                  repo_name=repo_name, repo_id=23, **overrides)

        self.assertEqual(clone_url, expected)

    def _quick_url(self, text, tmpl="""<a class="revision-link" href="%s">%s</a>""", url_=None):

        """

        Changes `some text url[foo]` => `some text <a href="/">foo</a>

        :param text:

        """

        import re

        # quickly change expected url[] into a link

        URL_PAT = re.compile(r'(?:url\[)(.+?)(?:\])')

        def url_func(match_obj):

            _url = match_obj.groups()[0]

            return tmpl % (url_ or '/some-url', _url)

        return URL_PAT.sub(url_func, text)

    @parameterized.expand([

      ("",

       some text lalala""",

       "https://foo.bar.com")

    ])

    def test_urlify_test(self, sample, expected, url_):

        from kallithea.lib.helpers import urlify_text

        expected = self._quick_url(expected,

                                   tmpl="""<a href="%s">%s</a>""", url_=url_)

        self.assertEqual(urlify_text(sample), expected)

    @parameterized.expand([

      ("", None),

      ("/_2", '2'),

      ("_2", '2'),

      ("/_2/", '2'),

      ("_2/", '2'),

      ("/_21", '21'),

      ("_21", '21'),

      ("/_21/", '21'),

      ("_21/", '21'),

      ("/_21/foobar", '21'),

      ("_21/121", '21'),

      ("/_21/_12", '21'),

    ])

    def test_get_repo_by_id(self, test, expected):

        from kallithea.lib.utils import _extract_id_from_repo_name

        _test = _extract_id_from_repo_name(test)

        self.assertEqual(_test, expected, msg='url:%s, got:`%s` expected: `%s`'

                                              % (test, _test, expected))

#!/bin/sh

psql -U postgres -h localhost -c 'drop database if exists kallithea;'

psql -U postgres -h localhost -c 'create database kallithea;'

API_KEY=`psql -R " " -A -U postgres -h localhost -c "select api_key from users where admin=TRUE" -d kallithea | awk '{print $2}'`

echo "run those after running server"

sleep 3

kallithea-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_user username:demo1 password:qweqwe email:demo1@example.com

kallithea-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_user username:demo2 password:qweqwe email:demo2@example.com

kallithea-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_user username:demo3 password:qweqwe email:demo3@example.com

kallithea-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 create_user_group group_name:demo12

kallithea-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 add_user_to_user_group usergroupid:demo12 userid:demo1

kallithea-api --apikey=$API_KEY --apihost=http://127.0.0.1:5001 add_user_to_user_group usergroupid:demo12 userid:demo2

echo "killing server"

import os

import sys

import shutil

import logging

from os.path import join as jn

from os.path import dirname as dn

from tempfile import _RandomNameSequence

from subprocess import Popen, PIPE

from paste.deploy import appconfig

from sqlalchemy import engine_from_config

from kallithea.lib.utils import add_cache

from kallithea.model import init_model

from kallithea.model import meta

from kallithea.model.db import User, Repository

from kallithea.lib.auth import get_crypt_password

from kallithea.tests import TESTS_TMP_PATH, HG_REPO

from kallithea.config.environment import load_environment

rel_path = dn(dn(dn(dn(os.path.abspath(__file__)))))

load_environment(conf.global_conf, conf.local_conf)

add_cache(conf)

USER = 'test_admin'

PASS = 'test12'

METHOD = 'pull'

DEBUG = True

log = logging.getLogger(__name__)

class Command(object):

    def __init__(self, cwd):

        self.cwd = cwd

    def execute(self, cmd, *args):

        """Runs command on the system with given ``args``.

        """

        command = cmd + ' ' + ' '.join(args)

        log.debug('Executing %s' % command)

        if DEBUG:

            print command

        p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd)

        stdout, stderr = p.communicate()

        if DEBUG:

            print stdout, stderr

        return stdout, stderr

from os.path import join as jn

from os.path import dirname as dn

__here__ = os.path.abspath(__file__)

__root__ = dn(dn(dn(__here__)))

sys.path.append(__root__)

from kallithea.lib import vcs

from kallithea.lib.compat import OrderedSet

from kallithea.lib.vcs.exceptions import RepositoryError

PASES = 3

HOST = 'http://127.0.0.1'

PORT = 5000

BASE_URI = '%s:%s/' % (HOST, PORT)

if len(sys.argv) == 2:

    BASE_URI = sys.argv[1]

if not BASE_URI.endswith('/'):

    BASE_URI += '/'

print 'Crawling @ %s' % BASE_URI

BASE_URI += '%s'

PROJECTS = [

    #'linux-magx-pbranch',

    'CPython',

    'kallithea',

]

cj = cookielib.FileCookieJar('/tmp/rc_test_cookie.txt')

o = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))

o.addheaders = [

    ('User-agent', 'kallithea-crawler'),

    ('Accept-Language', 'en - us, en;q = 0.5')

]

urllib2.install_opener(o)

def _get_repo(proj):

    if isinstance(proj, basestring):

        repo = vcs.get_repo(jn(PROJECT_PATH, proj))

        proj = proj

    else:

        repo = proj

        proj = repo.name

        self.assertEqual(parse_datetime('3 d'), expected)

        self.assertEqual(parse_datetime('3 day'), expected)

        self.assertEqual(parse_datetime('3 days'), expected)

    def test_weeks(self):

        timestamp = datetime.datetime.today() - datetime.timedelta(days=3 * 7)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        self.assertEqual(parse_datetime('3w'), expected)

        self.assertEqual(parse_datetime('3 w'), expected)

        self.assertEqual(parse_datetime('3 week'), expected)

        self.assertEqual(parse_datetime('3 weeks'), expected)

    def test_mixed(self):

        timestamp = datetime.datetime.today() - datetime.timedelta(days=2 * 7 + 3)

        args = timestamp.timetuple()[:3] + (0, 0, 0, 0)

        expected = datetime.datetime(*args)

        self.assertEqual(parse_datetime('2w3d'), expected)

        self.assertEqual(parse_datetime('2w 3d'), expected)

        self.assertEqual(parse_datetime('2w 3 days'), expected)

        self.assertEqual(parse_datetime('2 weeks 3 days'), expected)

class TestAuthorExtractors(unittest.TestCase):

                  ('username <user@email.com>',

                    ('username', 'user@email.com')),

                  ('username <user@email.com',

                   ('username', 'user@email.com')),

                  ('broken missing@email.com',

                   ('broken', 'missing@email.com')),

                  ('<justemail@mail.com>',

                   ('', 'justemail@mail.com')),

                  ('justname',

                   ('justname', '')),

                  ('Mr Double Name withemail@email.com ',

                   ('Mr Double Name', 'withemail@email.com')),

                  ]

    def test_author_email(self):

        for test_str, result in self.TEST_AUTHORS:

            self.assertEqual(result[1], author_email(test_str))

    def test_author_name(self):

        for test_str, result in self.TEST_AUTHORS:

            self.assertEqual(result[0], author_name(test_str))