~launchpad-pqm/launchpad/devel

# Copyright 2011 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

"""Fixture code for YUITest + XHR integration testing."""

__metaclass__ = type

__all__ = [

    'login_as_person',

    'make_suite',

    'setup',

    'YUITestFixtureControllerView',

]

from fnmatch import fnmatchcase

import os

import sys

from textwrap import dedent

import traceback

import unittest

from lazr.restful import ResourceJSONEncoder

from lazr.restful.utils import get_current_browser_request

import simplejson

from zope.component import getUtility

from zope.exceptions.exceptionformatter import format_exception

from zope.interface import implements

from zope.publisher.interfaces import NotFound

from zope.publisher.interfaces.http import IResult

from zope.security.checker import (

    NamesChecker,

    ProxyFactory,

    )

from zope.security.proxy import removeSecurityProxy

from zope.session.interfaces import IClientIdManager

from lp.app.versioninfo import revno

from lp.services.config import config

from lp.services.webapp.interfaces import (

    IOpenLaunchBag,

    IPlacelessAuthUtility,

    )

from lp.services.webapp.login import logInPrincipal

from lp.services.webapp.publisher import LaunchpadView

from lp.testing import AbstractYUITestCase

from lp.testing.layers import (

    DatabaseLayer,

    LaunchpadLayer,

    LayerProcessController,

    LibrarianLayer,

    YUIAppServerLayer,

    )

EXPLOSIVE_ERRORS = (SystemExit, MemoryError, KeyboardInterrupt)

class setup:

    """Decorator to mark a function as a fixture available from JavaScript.

    This makes the function available to call from JS integration tests over

    XHR.  The fixture setup can have one or more cleanups tied to it with

    ``add_cleanup`` decorator/callable and can be composed with another

    function with the ``extend`` decorator/callable.

    """

    def __init__(self, function, extends=None):

        self._cleanups = []

        self._function = function

        self._extends = extends

        # We can't use locals because we want to affect the function's module,

        # not this one.

        module = sys.modules[function.__module__]

        fixtures = getattr(module, '_fixtures_', None)

        if fixtures is None:

            fixtures = module._fixtures_ = {}

        fixtures[function.__name__] = self

    def __call__(self, request, data):

        """Call the originally decorated setup function."""

        if self._extends is not None:

            self._extends(request, data)

        self._function(request, data)

    def add_cleanup(self, function):

        """Add a cleanup function to be executed on teardown, FILO."""

        self._cleanups.append(function)

        return self

    def teardown(self, request, data):

        """Run all registered cleanups.  If no cleanups, a no-op."""

        for f in reversed(self._cleanups):

            f(request, data)

        if self._extends is not None:

            self._extends.teardown(request, data)

    def extend(self, function):

        return setup(function, self)

def login_as_person(person):

    """This is a helper function designed to be used within a fixture.

    Provide a person, such as one generated by LaunchpadObjectFactory, and

    the browser will become logged in as this person.

    Explicit tear-down is unnecessary because the database is reset at the end

    of every test, and the cookie is discarded.

    """

    if person.is_team:

        raise AssertionError("Please do not try to login as a team")

    email = removeSecurityProxy(person.preferredemail).email

    request = get_current_browser_request()

    assert request is not None, "We do not have a browser request."

    authutil = getUtility(IPlacelessAuthUtility)

    principal = authutil.getPrincipalByLogin(email, want_password=False)

    launchbag = getUtility(IOpenLaunchBag)

    launchbag.setLogin(email)

    logInPrincipal(request, principal, email)

class CloseDbResult:

    implements(IResult)

    # This is machinery, not content.  We specify our security checker here

    # directly for clarity.

    __Security_checker__ = NamesChecker(['next', '__iter__'])

    def __iter__(self):

        try:

            # Reset the session.

            LaunchpadLayer.resetSessionDb()

            # Yield control to asyncore for a second, just to be a

            # little bit nice.  We could be even nicer by moving this

            # whole teardown/setup dance to a thread and waiting for

            # it to be done, but there's not a (known) compelling need

            # for that right now, and doing it this way is slightly

            # simpler.

            yield ''

            DatabaseLayer.testSetUp()

            yield ''

            # Reset the librarian.

            LibrarianLayer.testTearDown()

            yield ''

            # Reset the database.

            DatabaseLayer.testTearDown()

            yield ''

            LibrarianLayer.testSetUp()

        except (SystemExit, KeyboardInterrupt):

            raise

        except:

            print "Hm, serious error when trying to clean up the test."

            traceback.print_exc()

        # We're done, so we can yield the body.

        yield '\n'

class YUITestFixtureControllerView(LaunchpadView):

    """Dynamically loads YUI test along their fixtures run over an app server.

    """

    JAVASCRIPT = 'JAVASCRIPT'

    HTML = 'HTML'

    SETUP = 'SETUP'

    TEARDOWN = 'TEARDOWN'

    INDEX = 'INDEX'

    page_template = dedent("""\

        <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"

          "http://www.w3.org/TR/html4/strict.dtd">

        <html>

          <head>

          <title>Test</title>

          <script type="text/javascript"

            src="/+icing/rev%(revno)s/build/launchpad.js"></script>

          <link rel="stylesheet"

            href="/+icing/yui/assets/skins/sam/skin.css"/>

          <link rel="stylesheet" href="/+icing/rev%(revno)s/combo.css"/>

          <style>

          /* Taken and customized from testlogger.css */

          .yui-console-entry-src { display:none; }

          .yui-console-entry.yui-console-entry-pass .yui-console-entry-cat {

            background-color: green;

            font-weight: bold;

            color: white;

          }

          .yui-console-entry.yui-console-entry-fail .yui-console-entry-cat {

            background-color: red;

            font-weight: bold;

            color: white;

          }

          .yui-console-entry.yui-console-entry-ignore .yui-console-entry-cat {

            background-color: #666;

            font-weight: bold;

            color: white;

          }

          </style>

          <script type="text/javascript" src="%(test_module)s"></script>

        </head>

        <body class="yui3-skin-sam">

          <div id="log"></div>

          <p>Want to re-run your test?</p>

          <ul>

            <li><a href="?">Reload test JS</a></li>

            <li><a href="?reload=1">Reload test JS and the associated

                                    Python fixtures</a></li>

          </ul>

          <p>Don't forget to run <code>make jsbuild</code> and then do a

             hard reload of this page if you change a file that is built

             into launchpad.js!</p>

          <p>If you change Python code other than the fixtures, you must

             restart the server.  Sorry.</p>

        </body>

        </html>

        """)

    index_template = dedent("""\

        <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"

          "http://www.w3.org/TR/html4/strict.dtd">

        <html>

          <head>

          <title>YUI XHR Tests</title>

          <script type="text/javascript"

            src="/+icing/rev%(revno)s/build/launchpad.js"></script>

          <link rel="stylesheet"

            href="/+icing/yui/assets/skins/sam/skin.css"/>

          <link rel="stylesheet" href="/+icing/rev%(revno)s/combo.css"/>

          <style>

          ul {

            text-align: left;

          }

          body, ul, h1 {

            margin: 0.3em;

            padding: 0.3em;

          }

        </style>

        </head>

        <body class="yui3-skin-sam">

          <h1>YUI XHR Tests</h1>

          <ul>%(tests)s</ul>

        </body>

        </html>

        """)

    def __init__(self, context, request):

        super(YUITestFixtureControllerView, self).__init__(context, request)

        self.names = []

        self.action = None

        self.fixtures = []

    @property

    def traversed_path(self):

        return os.path.join(*self.names)

    def initialize(self):

        if not self.names:

            self.action = self.INDEX

            return

        path, ext = os.path.splitext(self.traversed_path)

        full_path = os.path.join(config.root, 'lib', path)

        if not os.path.exists(full_path + '.py'):

            raise NotFound(self, full_path + '.py', self.request)

        if not os.path.exists(full_path + '.js'):

            raise NotFound(self, full_path + '.js', self.request)

        if ext == '.js':

            self.action = self.JAVASCRIPT

        else:

            if self.request.method == 'GET':

                self.action = self.HTML

            else:

                self.fixtures = self.request.form['fixtures'].split(',')

                if self.request.form['action'] == 'setup':

                    self.action = self.SETUP

                else:

                    self.action = self.TEARDOWN

    # The following two zope methods publishTraverse and browserDefault

    # allow this view class to take control of traversal from this point

    # onwards.  Traversed names just end up in self.names.

    def publishTraverse(self, request, name):

        """Traverse to the given name."""

        # The two following constraints are enforced by the publisher.

        assert os.path.sep not in name, (

            'traversed name contains os.path.sep: %s' % name)

        assert name != '..', 'traversing to ..'

        if name:

            self.names.append(name)

        return self

    def browserDefault(self, request):

        return self, ()

    @property

    def module_name(self):

        return '.'.join(self.names)

    def get_fixtures(self):

        module = __import__(

            self.module_name, globals(), locals(), ['_fixtures_'], 0)

        return module._fixtures_

    def renderINDEX(self):

        root = os.path.join(config.root, 'lib')

        test_lines = []

        for path in find_tests(root):

            test_path = '/+yuitest/' + '/'.join(path)

            module_name = '.'.join(path)

            try:

                module = __import__(

                    module_name, globals(), locals(), ['test_suite'], 0)

            except ImportError:

                warning = 'cannot import Python fixture file'

            else:

                try:

                    suite_factory = module.test_suite

                except AttributeError:

                    warning = 'cannot find test_suite'

                else:

                    try:

                        suite = suite_factory()

                    except EXPLOSIVE_ERRORS:

                        raise

                    except:

                        warning = 'test_suite raises errors'

                    else:

                        case = None

                        for case in suite:

                            if isinstance(case, YUIAppServerTestCase):

                                root_url = config.appserver_root_url(

                                    case.facet)

                                if root_url != 'None':

                                    test_path = root_url + test_path

                                warning = ''

                                break

                        else:

                            warning = (

                                'test suite is not instance of '

                                'YUIAppServerTestCase')

            link = '<a href="%s">%s</a>' % (test_path, test_path)

            if warning:

                warning = ' <span class="warning">%s</span>' % warning

            test_lines.append('<li>%s%s</li>' % (link, warning))

        return self.index_template % {

            'revno': revno,

            'tests': '\n'.join(test_lines)}

    def renderJAVASCRIPT(self):

        self.request.response.setHeader('Content-Type', 'text/javascript')

        self.request.response.setHeader('Cache-Control', 'no-cache')

        return open(

            os.path.join(config.root, 'lib', self.traversed_path))

    def renderHTML(self):

        self.request.response.setHeader('Content-Type', 'text/html')

        self.request.response.setHeader('Cache-Control', 'no-cache')

        if ('INTERACTIVE_TESTS' in os.environ and

            'reload' in self.request.form):

            # We should try to reload the module.

            module = sys.modules.get(self.module_name)

            if module is not None:

                del module._fixtures_

                reload(module)

        return self.page_template % dict(

            test_module='/+yuitest/%s.js' % self.traversed_path,

            revno=revno)

    def renderSETUP(self):

        data = {}

        fixtures = self.get_fixtures()

        try:

            for fixture_name in self.fixtures:

                __traceback_info__ = (fixture_name, data)

                fixtures[fixture_name](self.request, data)

        except EXPLOSIVE_ERRORS:

            raise

        except:

            self.request.response.setStatus(500)

            result = ''.join(format_exception(*sys.exc_info()))

        else:

            self.request.response.setHeader(

                'Content-Type', 'application/json')

            # We use the ProxyFactory so that the restful

            # redaction code is always used.

            result = simplejson.dumps(

                ProxyFactory(data), cls=ResourceJSONEncoder)

        return result

    def renderTEARDOWN(self):

        data = simplejson.loads(self.request.form['data'])

        fixtures = self.get_fixtures()

        try:

            for fixture_name in reversed(self.fixtures):

                __traceback_info__ = (fixture_name, data)

                fixtures[fixture_name].teardown(self.request, data)

        except EXPLOSIVE_ERRORS:

            raise

        except:

            self.request.response.setStatus(500)

            result = ''.join(format_exception(*sys.exc_info()))

        else:

            # Remove the session cookie, in case we have one.

            self.request.response.expireCookie(

                getUtility(IClientIdManager).namespace)

            # Blow up the database once we are out of this transaction

            # by passing a result that will do so when it is iterated

            # through in asyncore.

            self.request.response.setHeader('Content-Length', 1)

            result = CloseDbResult()

        return result

    def render(self):

        return getattr(self, 'render' + self.action)()

def find_tests(root):

    for dirpath, dirnames, filenames in os.walk(root):

        dirpath = os.path.relpath(dirpath, root)

        for filename in filenames:

            if fnmatchcase(filename, 'test_*.js'):

                name, ext = os.path.splitext(filename)

                if name + '.py' in filenames:

                    names = dirpath.split(os.path.sep)

                    names.append(name)

                    yield names

# This class cannot be imported directly into a test suite because

# then the test loader will sniff and (try to) run it.  Use make_suite

# instead (or import this module rather than this class).

class YUIAppServerTestCase(AbstractYUITestCase):

    "Instantiate this test case with the Python fixture module name."

    layer = YUIAppServerLayer

    _testMethodName = 'runTest'

    # 5 minutes for the suite.  Hopefully we never get close to this.

    suite_timeout = 300000

    # 12 seconds for each test.  Hopefully they are three or less for

    # yuixhr tests, and less than one for pure JS tests, but

    # occasionally buildbot runs over six seconds even for tests that

    # are well-behaved locally and on ec2, so we up the limit to 12..

    incremental_timeout = 12000

    # 45 seconds for the first test, to include warmup time.  These times

    # are wildly large, and they are only necessary on buildbot.  ec2 and

    # local instances are much, much faster.  We have not yet investigated

    # why buildbot is so slow for these.

    initial_timeout = 45000

    def __init__(self, module_name, facet='mainsite'):

        self.module_name = module_name

        self.facet = facet

        # This needs to be done early so the "id" is set correctly.

        self.test_path = self.module_name.replace('.', '/')

        super(YUIAppServerTestCase, self).__init__()

    def setUp(self):

        config = LayerProcessController.appserver_config

        root_url = config.appserver_root_url(self.facet)

        self.html_uri = '%s/+yuitest/%s' % (root_url, self.test_path)

        super(YUIAppServerTestCase, self).setUp()

    runTest = AbstractYUITestCase.checkResults

def make_suite(module_name, facet='mainsite'):

    return unittest.TestSuite([YUIAppServerTestCase(module_name, facet)])