예제 #1
0
    def test_enable_copy_args(self):
        config = rv.get_configuration()

        class M(object):
            def m(self):
                self.x = 123

        @rv.monitor(m=M.m)
        @rv.spec(when=rv.POST)
        def spec(event):
            if hasattr(event.fn.m.inputs[0], 'x'):
                raise ValueError("buffy")
            self.assertEquals(event.fn.m.outputs[0].x, 123)

        a = M()
        a.m()

        b = M()
        rv.configure(enable_copy_args=False)

        with self.assertRaises(ValueError) as e:
            b.m()
        self.assertEquals(e.exception.message, "buffy")

        rv.configure(**config)
예제 #2
0
    def test_configuration(self):
        config = rv.get_configuration()
        self.assertEquals(rv.get_configuration()['error_handler'], rv.DEFAULT_ERROR_HANDLER)
        self.assertEquals(rv.get_configuration()['enable_copy_args'], True)

        rv.configure(error_handler=1234, enable_copy_args=False)
        self.assertEquals(rv.get_configuration()['error_handler'], 1234)
        self.assertEquals(rv.get_configuration()['enable_copy_args'], False)

        rv.configure(**config)
        self.assertEquals(rv.get_configuration()['error_handler'], rv.DEFAULT_ERROR_HANDLER)
        self.assertEquals(rv.get_configuration()['enable_copy_args'], True)
예제 #3
0
    def test_log(self):
        rv.configure(error_handler=rv.LoggingErrorHandler())
        for i, t in enumerate(error_levels):
            class M(object):
                def m(self):
                    pass

            @rv.monitor(m=M.m)
            @rv.spec(level=t)
            def spec(event):
                assert False, "of time"

            a = M()
            a.m()
            self.assertLog(t, "of time")
예제 #4
0
    def test_raise(self):
        for level_i, level in enumerate(error_levels):
            rv.configure(error_handler=rv.RaiseExceptionErrorHandler(level=level))
            for i, t in enumerate(error_levels):
                class M(object):
                    def m(self):
                        pass

                @rv.monitor(m=M.m)
                @rv.spec(level=t)
                def spec(event):
                    assert False, "of time"

                a = M()
                if i < level_i:
                    a.m()
                else:
                    with self.assertRaises(AssertionError) as e:
                        a.m()
                    self.assertEquals(e.exception.message, 'of time')
예제 #5
0
 def tearDown(self):
     super(TestSpecErrorLevels, self).tearDown()
     rv.configure(**self.old_rv_config)
예제 #6
0
 def tearDown(self):
     super(TestRVWithLoggingErrorHandler, self).tearDown()
     rv.configure(**self.old_rv_config)
예제 #7
0
 def setUp(self):
     super(TestRVWithLoggingErrorHandler, self).setUp()
     self.old_rv_config = rv.get_configuration()
     rv.configure(error_handler=rv.LoggingErrorHandler())
예제 #8
0
from pythonrv import rv
class CustomErrorHandler(object):
    def handle(self, level, errors):
        if level == rv.CRITICAL:
            # raise only the first error
            raise errors[0]

rv.configure(error_handler=CustomErrorHandler())

@rv.monitor(...)
@rv.spec(level=rv.CRITICAL)
def spec(event):
    assert False
from pythonrv import rv
from django.core.handlers.base import BaseHandler
# disable copying to work around bug in django
rv.configure(enable_copy_args=False)

# monitor the main request-processing method that
# has access to both the request and the response
@rv.monitor(bh=BaseHandler.get_response)
@rv.spec(when=rv.POST)
def ensure_auth(event):
  request = event.called_function.inputs[1]
  response = event.called_function.result
  if requires_auth(request, response):
    assert (request.user.is_authenticated(),
      "The current user is not authenticated")
    assert (request.user.is_active,
      "The current user is not active")

# a helper function for when authentication is
# required
def requires_auth(req, res):
  # only ok responses need authentication
  if res.status_code != 200:
    return False
  # requests to /login does not require auth nor
  # does /appmedia, which  is only css and images
  if (req.path.startswith("/login") or
      req.path.startswith("/appmedia")):
    return False
  return True
예제 #10
0
#need import of thread_safe to get rv it turns out
import thread_safe_specs
import threading
import logging
import time

from pythonrv import rv

rv.configure(error_handler=rv.LoggingErrorHandler())
logging.basicConfig(filename="log",
                    level=logging.ERROR,
                    filemode="w",
                    format="%(asctime)s - %(levelname)s - %(message)s")
from testmod import lock_constr, incr

i = 0
i_lock = threading.Lock()


def nsfw_test():
    global i
    for x in range(10000):
        i = incr(i)


def sfw_test():
    #use global variable i
    global i
    i_lock.acquire()
    lock_constr()
    try:
예제 #11
0
#!/usr/bin/env python

import sys
import os

sys.path.append(os.path.join(os.path.dirname(__file__), '../..'))
import fib_rvspecs

import logging
from pythonrv import rv
rv.configure(error_handler=rv.LoggingErrorHandler())
logging.basicConfig(filename="log",
        level=logging.WARNING,
        filemode="w",
        format="%(asctime)s - %(levelname)s - %(message)s")

from fib import fib

def main():
    print "Fibonacci numbers:"
    for i in range(1, 20):
        print "%d -> %d" %(i, fib(i))

if __name__ == '__main__':
    main()