test_quickstart.py

import os
import shutil
import subprocess
import sys
import site
import unittest

from webtest import TestApp
from itertools import count
from venv import EnvBuilder
from tg.util import Bunch

from devtools.gearbox.quickstart import QuickstartCommand
from gearbox.commands.setup_app import SetupAppCommand


PY_VERSION = sys.version_info[:2]
PROJECT_NAME = 'TGTest-%02d'
ENV_NAME = 'TESTENV'
CLEANUP = True
COUNTER = count()
QUIET = '-q'  # Set this to -v to enable installed packages logging, or to -q to disable it


def get_passed_and_failed(env_cmd, python_cmd, testpath):
    """Run test suite under testpath, return set of passed tests."""
    os.chdir(testpath)
    args = '. %s; %s -W ignore -mpytest -v --no-header --no-summary' % (env_cmd, python_cmd)
    out = subprocess.Popen(args,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.STDOUT,
                           shell=True, encoding="utf-8").communicate()[0]
    passed, failed = [], []
    lines = out.splitlines()
    for line in lines:
        test = None
        line = line.split(' ', 1)
        if line[0].startswith('tgtest'):
            test = line[0]
        if test and len(line) == 2:
            line[1] = line[1].split()[0].strip()
            if line[1] in ('passed', 'PASSED'):
                passed.append(test)
                test = None
            elif line[1] in ('ERROR', 'FAILED'):
                failed.append(test)
                test = None
    return passed, failed, lines


class BaseTestQuickStart(object):

    args = ''
    preinstall = []

    @classmethod
    def setUpClass(cls):
        cls.command = QuickstartCommand(None, {})
        cls.parser = cls.command.get_parser('tg2devtools-test')

        cls.base_dir = os.getcwd()

        # All the envs must be named equally due to python not supporting
        # unloading modules, so the modules loaded on first fixture must
        # be in the same place on the next fixtures.
        cls.env_dir = os.path.join(os.path.abspath(cls.base_dir), ENV_NAME)

        # directory for executable scripts in the virtual environment
        cls.bin_dir = os.path.join(cls.env_dir,
            'Scripts' if sys.platform == 'win32' else 'bin')

        # This is to avoid previously failed tests to break successive fixtures
        shutil.rmtree(cls.env_dir, ignore_errors=True)

        # Create virtualenv for current fixture
        EnvBuilder(with_pip=True, symlinks=True).create(cls.env_dir)

        # Enable the newly created virtualenv
        cls.pip_cmd, cls.python_cmd, cls.env_cmd, site_packages = cls.enter_virtualenv()

        # Reinstall gearbox to force it being installed inside the
        # virtualenv using supported PBR version
        cls.run_pip(['install', '-U', 'setuptools', 'pip', 'wheel'])
        cls.run_pip(['install', '-I', 'git+https://github.com/TurboGears/tempita'])
        cls.run_pip(['install', '--pre', '-I', 'gearbox'])

        # Then install specific requirements
        for p in cls.preinstall:
            cls.run_pip(['install', '--pre', '-I', p])

        cls.run_pip(['install', '-I', 'git+https://github.com/TurboGears/crank'])
        cls.run_pip(['install', '-I', 'git+https://github.com/TurboGears/backlash'])
        cls.run_pip(['install', '-I', 'git+https://github.com/TurboGears/tgext.debugbar'])

        # Install TurboGears from development branch to test future compatibility
        cls.venv_uninstall('WebOb')
        cls.venv_uninstall('TurboGears2')
        cls.run_pip(['install', '--pre', '-I', 'git+https://github.com/TurboGears/tg2.git@development'])

        # Install tg.devtools inside the virtualenv
        cls.run_pip(['install', '--pre', '-e', cls.base_dir])

        # Install All Template Engines inside the virtualenv so that
        # They all get configured as we share a single python process
        # for all configurations.
        for engine in ("Jinja2", "Genshi", "make", "kajiki"):
            cls.run_pip(['install', '--upgrade', '--no-deps', '--force-reinstall',
                         '--pre', engine])

        # This is to avoid the TGTest package to be detected as
        # being already installed.
        proj_name = PROJECT_NAME % next(COUNTER)
        cls.proj_dir = os.path.join(cls.base_dir, proj_name)

        # Create a quickstarted app by runnig 'gearbox quickstart'
        opts = cls.parser.parse_args(cls.args.split() + [proj_name])
        cls.command.run(opts)

        # Install quickstarted project dependencies
        cls.run_pip(['install', '--pre', '-e', '%s[testing]' % cls.proj_dir])

        # Mark the packages as installed even outside the virtualenv
        # so we can load app in tests which are not executed inside
        # the newly created virtualenv.
        site.addsitedir(site_packages)

    def setUp(self):
        os.chdir(self.proj_dir)
        from paste.deploy import loadapp
        self.app = loadapp('config:test.ini', relative_to=self.proj_dir)
        self.app = TestApp(self.app)

    def init_database(self):
        os.chdir(self.proj_dir)
        cmd = SetupAppCommand(Bunch(options=Bunch(verbose_level=1)), Bunch())
        try:
            cmd.run(Bunch(config_file='config:test.ini', section_name=None))
        except:
            # DB already initialised, ignore it.
            pass

    @classmethod
    def tearDownClass(cls):
        # This is in case the tests have been skipped
        if not hasattr(cls, 'past_working_set_state'):
            return

        cls.exit_virtualenv()

        os.chdir(cls.base_dir)
        if CLEANUP:
            shutil.rmtree(cls.proj_dir, ignore_errors=False)
            shutil.rmtree(cls.env_dir, ignore_errors=False)

    @classmethod
    def enter_virtualenv(cls):
        cls.old_os_path = os.environ['PATH']
        os.environ['PATH'] = cls.env_dir + os.pathsep + cls.old_os_path

        base = os.path.abspath(cls.env_dir)
        site_packages = os.path.join(
            base, 'lib', 'python%s.%s' % sys.version_info[:2], 'site-packages'
        )
        cls.prev_sys_path = list(sys.path)

        cls.past_prefix = sys.prefix
        cls.past_real_prefix = getattr(sys, 'real_prefix', None)

        site.addsitedir(site_packages)
        sys.real_prefix = sys.prefix
        sys.prefix = base

        # Move the added items to the front of the path:
        new_sys_path = []
        for item in list(sys.path):
            if item not in cls.prev_sys_path:
                new_sys_path.append(item)
                sys.path.remove(item)
        sys.path[:0] = new_sys_path

        return (os.path.join(cls.bin_dir, 'pip'),
                os.path.join(cls.bin_dir, 'python'),
                os.path.join(cls.bin_dir, 'activate'),
                site_packages)

    @classmethod
    def exit_virtualenv(cls):
        os.environ['PATH'] = cls.old_os_path
        sys.path = cls.prev_sys_path
        sys.prefix = cls.past_prefix

        if cls.past_real_prefix is not None:
            sys.real_prefix = cls.past_real_prefix
        else:
            delattr(sys, 'real_prefix')

    @classmethod
    def run_pip(cls, opt):
        return subprocess.call([cls.python_cmd, '-mpip', QUIET] + opt)

    @classmethod
    def venv_uninstall(cls, package):
        # Do it 5 times to ensure it was uninstalled for real.
        # Due to the -I used in other commands,
        # multiple versions of the same package might be installed concurrently.
        for i in range(5):
            cls.run_pip(['uninstall', '-y', package])


class CommonTestQuickStart(BaseTestQuickStart):

    # tests that must be passed
    pass_tests = [
        '/tests/functional/test_authentication.',
        '/tests/functional/test_root.',
        '/tests/models/test_auth.']
    # tests that must fail (should not exist)
    fail_tests = []
    # tests that must not be run
    skip_tests = []

    def test_index(self):
        resp = self.app.get('/')
        assert 'Welcome to TurboGears' in resp, resp

    def test_login(self):
        resp = self.app.get('/login')
        assert '<h1>Login</h1>' in resp

    def test_subtests(self):
        passed, failed, lines = get_passed_and_failed(self.env_cmd,
                                                      self.python_cmd,
                                                      os.path.join(self.proj_dir))
        for has_failed in failed:
            for must_fail in self.fail_tests:
                if must_fail in has_failed:
                    break
            else:
                assert False, 'Failed %s\n\n%s' % (has_failed, '\n'.join(lines))
        for must_pass in self.pass_tests:
            for has_passed in passed:
                if must_pass in has_passed:
                    break
            else:
                print("Passed:\n" + '\n'.join(passed))
                assert False, 'Did not pass %s\n\n%s' % (must_pass, '\n'.join(lines))
        for must_fail in self.fail_tests:
            for has_failed in failed:
                if must_fail in has_failed:
                    break
            else:
                print("Failed:\n" + '\n'.join(failed))
                assert False, 'Did not fail %s' % must_fail
        for must_skip in self.skip_tests:
            for has_run in passed + failed:
                if must_skip in has_run:
                    print("Run:\n" + '\n'.join(passed + failed))
                    assert False, 'Did not skip %s' % must_skip


class CommonTestQuickStartWithAuth(CommonTestQuickStart):
    def test_secured_controller(self):
        assert (
            '<h1>Login</h1>' in self.app.get('/secc/', status=302).follow()
        )

    def test_secured_controller_with_prefix(self):
        resp1 = self.app.get('/prefix/secc/', extra_environ={'SCRIPT_NAME': '/prefix'}, status=302)
        assert (
            resp1.headers['Location'] == 'http://localhost/prefix/login?came_from=%2Fprefix%2Fsecc%2F'
        ), resp1.headers['Location']
        resp2 = resp1.follow(extra_environ={'SCRIPT_NAME': '/prefix'})
        assert '/prefix/login_handler' in resp2, resp2

    def test_login_with_prefix(self):
        self.init_database()
        resp1 = self.app.post('/prefix/login_handler?came_from=%2Fprefix%2Fsecc%2F',
                              params={'login': 'editor', 'password': 'editpass'},
                              extra_environ={'SCRIPT_NAME': '/prefix'})
        assert (
            resp1.headers['Location'] == 'http://localhost/prefix/post_login?came_from=%2Fprefix%2Fsecc%2F'
        ), resp1.headers['Location']
        resp2 = resp1.follow(extra_environ={'SCRIPT_NAME': '/prefix'})
        assert (
            resp2.headers['Location'] == 'http://localhost/prefix/secc/'
        ), resp2.headers['Location']

    def test_login_failure_with_prefix(self):
        self.init_database()
        resp = self.app.post('/prefix/login_handler?came_from=%2Fprefix%2Fsecc%2F',
                             params={'login': 'WRONG', 'password': 'WRONG'},
                             extra_environ={'SCRIPT_NAME': '/prefix'})
        location = resp.headers['Location']
        assert 'http://localhost/prefix/login' in location, location
        assert 'came_from=%2Fprefix%2Fsecc%2F' in location, location


class TestDefaultQuickStart(CommonTestQuickStartWithAuth, unittest.TestCase):
    args = ''

    @classmethod
    def setUpClass(cls):
        super(TestDefaultQuickStart, cls).setUpClass()

    def setUp(self):
        super(TestDefaultQuickStart, self).setUp()


class TestMakoQuickStart(CommonTestQuickStart, unittest.TestCase):
    args = '--mako --nosa --noauth'

    pass_tests = ['/tests/functional/test_root.']
    skip_tests = [
        'TestRootController::test_secc',
        '/tests/functional/test_authentication.',
        '/tests/models/test_auth.']

    def test_login(self):
        self.app.get('/login', status=404)


class TestGenshiQuickStart(CommonTestQuickStart, unittest.TestCase):
    args = '--genshi --nosa --noauth'

    pass_tests = ['/tests/functional/test_root.']
    skip_tests = [
        'TestRootController::test_secc',
        '/tests/functional/test_authentication.',
        '/tests/models/test_auth.']

    def test_login(self):
        self.app.get('/login', status=404)


class TestJinjaQuickStart(CommonTestQuickStart, unittest.TestCase):
    args = '--jinja --nosa --noauth'

    pass_tests = ['/tests/functional/test_root.']
    skip_tests = [
        'TestRootController::test_secc',
        '/tests/functional/test_authentication.',
        '/tests/models/test_auth.']

    def test_login(self):
        self.app.get('/login', status=404)


class TestNoDBQuickStart(CommonTestQuickStart, unittest.TestCase):

    pass_tests = ['/tests/functional/test_root.']
    skip_tests = [
        'TestRootController::test_secc',
        '/tests/functional/test_authentication.',
        '/tests/models/test_auth.']

    args = '--nosa --noauth'

    def test_login(self):
        self.app.get('/login', status=404)


class TestNoAuthQuickStart(CommonTestQuickStart, unittest.TestCase):

    pass_tests = ['/tests/functional/test_root.']
    skip_tests = [
        'TestRootController::test_secc',
        '/tests/functional/test_authentication.',
        '/tests/models/test_auth.']

    args = '--noauth'

    @classmethod
    def setUpClass(cls):
        super(TestNoAuthQuickStart, cls).setUpClass()

    def setUp(self):
        super(TestNoAuthQuickStart, self).setUp()

    def test_login(self):
        self.app.get('/login', status=404)


class TestMingBQuickStart(CommonTestQuickStartWithAuth, unittest.TestCase):

    args = '--ming'
    # preinstall = ['Paste', 'PasteScript']  # Ming doesn't require those anymore

    @classmethod
    def setUpClass(cls):
        super(TestMingBQuickStart, cls).setUpClass()

    def setUp(self):
        super(TestMingBQuickStart, self).setUp()


class TestMinimalQuickStart(CommonTestQuickStart, unittest.TestCase):

    args = '--minimal-quickstart'

    def test_secc_is_removed(self):
        self.app.get('/secc', status=404)