[Zope3-checkins]
SVN: Zope3/branches/benji-testbrowser-with-real-browsers/src/
add work-in-progress version of zope.testbrowser that can use
an external
Benji York
benji at zope.com
Wed May 31 23:20:49 EDT 2006
Log message for revision 68420:
add work-in-progress version of zope.testbrowser that can use an external
browser as the backend
- no tests (yet)
- you have to start the browser yourself and point it at
http://localhost:8000/__resources__/start.html
- no support for forms (or controls) yet
- need to track down an intermittent bug (race condition)
Changed:
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/__init__.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/decoder.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/encoder.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/jsonfilter.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/scanner.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/__init__.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_fail.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass1.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass2.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass3.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_recursion.py
U Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/browser.py
U Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/interfaces.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remote.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remoteproxy.py
U Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/tests.py
A Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/utilities.py
-=-
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/__init__.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/__init__.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/__init__.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,221 @@
+r"""
+A simple, fast, extensible JSON encoder and decoder
+
+JSON (JavaScript Object Notation) <http://json.org> is a subset of
+JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
+interchange format.
+
+simplejson exposes an API familiar to uses of the standard library
+marshal and pickle modules.
+
+Encoding basic Python object hierarchies::
+
+ >>> import simplejson
+ >>> simplejson.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
+ '["foo", {"bar": ["baz", null, 1.0, 2]}]'
+ >>> print simplejson.dumps("\"foo\bar")
+ "\"foo\bar"
+ >>> print simplejson.dumps(u'\u1234')
+ "\u1234"
+ >>> print simplejson.dumps('\\')
+ "\\"
+ >>> print simplejson.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
+ {"a": 0, "b": 0, "c": 0}
+ >>> from StringIO import StringIO
+ >>> io = StringIO()
+ >>> simplejson.dump(['streaming API'], io)
+ >>> io.getvalue()
+ '["streaming API"]'
+
+Decoding JSON::
+
+ >>> import simplejson
+ >>> simplejson.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
+ [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
+ >>> simplejson.loads('"\\"foo\\bar"')
+ u'"foo\x08ar'
+ >>> from StringIO import StringIO
+ >>> io = StringIO('["streaming API"]')
+ >>> simplejson.load(io)
+ [u'streaming API']
+
+Specializing JSON object decoding::
+
+ >>> import simplejson
+ >>> def as_complex(dct):
+ ... if '__complex__' in dct:
+ ... return complex(dct['real'], dct['imag'])
+ ... return dct
+ ...
+ >>> simplejson.loads('{"__complex__": true, "real": 1, "imag": 2}',
+ ... object_hook=as_complex)
+ (1+2j)
+
+Extending JSONEncoder::
+
+ >>> import simplejson
+ >>> class ComplexEncoder(simplejson.JSONEncoder):
+ ... def default(self, obj):
+ ... if isinstance(obj, complex):
+ ... return [obj.real, obj.imag]
+ ... return simplejson.JSONEncoder.default(self, obj)
+ ...
+ >>> dumps(2 + 1j, cls=ComplexEncoder)
+ '[2.0, 1.0]'
+ >>> ComplexEncoder().encode(2 + 1j)
+ '[2.0, 1.0]'
+ >>> list(ComplexEncoder().iterencode(2 + 1j))
+ ['[', '2.0', ', ', '1.0', ']']
+
+
+Note that the JSON produced by this module is a subset of YAML,
+so it may be used as a serializer for that as well.
+"""
+__version__ = '1.3'
+__all__ = [
+ 'dump', 'dumps', 'load', 'loads',
+ 'JSONDecoder', 'JSONEncoder',
+]
+
+from decoder import JSONDecoder
+from encoder import JSONEncoder
+
+def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
+ allow_nan=True, cls=None, **kw):
+ """
+ Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
+ ``.write()``-supporting file-like object).
+
+ If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types
+ (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
+ will be skipped instead of raising a ``TypeError``.
+
+ If ``ensure_ascii`` is ``False``, then the some chunks written to ``fp``
+ may be ``unicode`` instances, subject to normal Python ``str`` to
+ ``unicode`` coercion rules. Unless ``fp.write()`` explicitly
+ understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
+ to cause an error.
+
+ If ``check_circular`` is ``False``, then the circular reference check
+ for container types will be skipped and a circular reference will
+ result in an ``OverflowError`` (or worse).
+
+ If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to
+ serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
+ in strict compliance of the JSON specification, instead of using the
+ JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+ To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+ ``.default()`` method to serialize additional types), specify it with
+ the ``cls`` kwarg.
+ """
+ if cls is None:
+ cls = JSONEncoder
+ iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+ check_circular=check_circular, allow_nan=allow_nan,
+ **kw).iterencode(obj)
+ # could accelerate with writelines in some versions of Python, at
+ # a debuggability cost
+ for chunk in iterable:
+ fp.write(chunk)
+
+def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
+ allow_nan=True, cls=None, **kw):
+ """
+ Serialize ``obj`` to a JSON formatted ``str``.
+
+ If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types
+ (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
+ will be skipped instead of raising a ``TypeError``.
+
+ If ``ensure_ascii`` is ``False``, then the return value will be a
+ ``unicode`` instance subject to normal Python ``str`` to ``unicode``
+ coercion rules instead of being escaped to an ASCII ``str``.
+
+ If ``check_circular`` is ``False``, then the circular reference check
+ for container types will be skipped and a circular reference will
+ result in an ``OverflowError`` (or worse).
+
+ If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to
+ serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
+ strict compliance of the JSON specification, instead of using the
+ JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+ To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+ ``.default()`` method to serialize additional types), specify it with
+ the ``cls`` kwarg.
+ """
+ if cls is None:
+ cls = JSONEncoder
+ return cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+ check_circular=check_circular, allow_nan=allow_nan, **kw).encode(obj)
+
+def load(fp, encoding=None, cls=None, object_hook=None, **kw):
+ """
+ Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
+ a JSON document) to a Python object.
+
+ If the contents of ``fp`` is encoded with an ASCII based encoding other
+ than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must
+ be specified. Encodings that are not ASCII based (such as UCS-2) are
+ not allowed, and should be wrapped with
+ ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``
+ object and passed to ``loads()``
+
+ ``object_hook`` is an optional function that will be called with the
+ result of any object literal decode (a ``dict``). The return value of
+ ``object_hook`` will be used instead of the ``dict``. This feature
+ can be used to implement custom decoders (e.g. JSON-RPC class hinting).
+
+ To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+ kwarg.
+ """
+ if cls is None:
+ cls = JSONDecoder
+ if object_hook is not None:
+ kw['object_hook'] = object_hook
+ return cls(encoding=encoding, **kw).decode(fp.read())
+
+def loads(s, encoding=None, cls=None, object_hook=None, **kw):
+ """
+ Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
+ document) to a Python object.
+
+ If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding
+ other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name
+ must be specified. Encodings that are not ASCII based (such as UCS-2)
+ are not allowed and should be decoded to ``unicode`` first.
+
+ ``object_hook`` is an optional function that will be called with the
+ result of any object literal decode (a ``dict``). The return value of
+ ``object_hook`` will be used instead of the ``dict``. This feature
+ can be used to implement custom decoders (e.g. JSON-RPC class hinting).
+
+ To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+ kwarg.
+ """
+ if cls is None:
+ cls = JSONDecoder
+ if object_hook is not None:
+ kw['object_hook'] = object_hook
+ return cls(encoding=encoding, **kw).decode(s)
+
+def read(s):
+ """
+ json-py API compatibility hook. Use loads(s) instead.
+ """
+ import warnings
+ warnings.warn("simplejson.loads(s) should be used instead of read(s)",
+ DeprecationWarning)
+ return loads(s)
+
+def write(obj):
+ """
+ json-py API compatibility hook. Use dumps(s) instead.
+ """
+ import warnings
+ warnings.warn("simplejson.dumps(s) should be used instead of write(s)",
+ DeprecationWarning)
+ return dumps(obj)
+
+
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/__init__.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/decoder.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/decoder.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/decoder.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,271 @@
+"""
+Implementation of JSONDecoder
+"""
+import re
+
+from simplejson.scanner import Scanner, pattern
+
+FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
+
+def _floatconstants():
+ import struct
+ import sys
+ _BYTES = '7FF80000000000007FF0000000000000'.decode('hex')
+ if sys.byteorder != 'big':
+ _BYTES = _BYTES[:8][::-1] + _BYTES[8:][::-1]
+ nan, inf = struct.unpack('dd', _BYTES)
+ return nan, inf, -inf
+
+NaN, PosInf, NegInf = _floatconstants()
+
+def linecol(doc, pos):
+ lineno = doc.count('\n', 0, pos) + 1
+ if lineno == 1:
+ colno = pos
+ else:
+ colno = pos - doc.rindex('\n', 0, pos)
+ return lineno, colno
+
+def errmsg(msg, doc, pos, end=None):
+ lineno, colno = linecol(doc, pos)
+ if end is None:
+ return '%s: line %d column %d (char %d)' % (msg, lineno, colno, pos)
+ endlineno, endcolno = linecol(doc, end)
+ return '%s: line %d column %d - line %d column %d (char %d - %d)' % (
+ msg, lineno, colno, endlineno, endcolno, pos, end)
+
+_CONSTANTS = {
+ '-Infinity': NegInf,
+ 'Infinity': PosInf,
+ 'NaN': NaN,
+ 'true': True,
+ 'false': False,
+ 'null': None,
+}
+
+def JSONConstant(match, context, c=_CONSTANTS):
+ return c[match.group(0)], None
+pattern('(-?Infinity|NaN|true|false|null)')(JSONConstant)
+
+def JSONNumber(match, context):
+ match = JSONNumber.regex.match(match.string, *match.span())
+ integer, frac, exp = match.groups()
+ if frac or exp:
+ res = float(integer + (frac or '') + (exp or ''))
+ else:
+ res = int(integer)
+ return res, None
+pattern(r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?')(JSONNumber)
+
+STRINGCHUNK = re.compile(r'(.*?)(["\\])', FLAGS)
+BACKSLASH = {
+ '"': u'"', '\\': u'\\', '/': u'/',
+ 'b': u'\b', 'f': u'\f', 'n': u'\n', 'r': u'\r', 't': u'\t',
+}
+
+DEFAULT_ENCODING = "utf-8"
+
+def scanstring(s, end, encoding=None, _b=BACKSLASH, _m=STRINGCHUNK.match):
+ if encoding is None:
+ encoding = DEFAULT_ENCODING
+ chunks = []
+ _append = chunks.append
+ begin = end - 1
+ while 1:
+ chunk = _m(s, end)
+ if chunk is None:
+ raise ValueError(
+ errmsg("Unterminated string starting at", s, begin))
+ end = chunk.end()
+ content, terminator = chunk.groups()
+ if content:
+ if not isinstance(content, unicode):
+ content = unicode(content, encoding)
+ _append(content)
+ if terminator == '"':
+ break
+ try:
+ esc = s[end]
+ except IndexError:
+ raise ValueError(
+ errmsg("Unterminated string starting at", s, begin))
+ if esc != 'u':
+ try:
+ m = _b[esc]
+ except KeyError:
+ raise ValueError(
+ errmsg("Invalid \\escape: %r" % (esc,), s, end))
+ end += 1
+ else:
+ esc = s[end + 1:end + 5]
+ try:
+ m = unichr(int(esc, 16))
+ if len(esc) != 4 or not esc.isalnum():
+ raise ValueError
+ except ValueError:
+ raise ValueError(errmsg("Invalid \\uXXXX escape", s, end))
+ end += 5
+ _append(m)
+ return u''.join(chunks), end
+
+def JSONString(match, context):
+ encoding = getattr(context, 'encoding', None)
+ return scanstring(match.string, match.end(), encoding)
+pattern(r'"')(JSONString)
+
+WHITESPACE = re.compile(r'\s*', FLAGS)
+
+def JSONObject(match, context, _w=WHITESPACE.match):
+ pairs = {}
+ s = match.string
+ end = _w(s, match.end()).end()
+ nextchar = s[end:end + 1]
+ # trivial empty object
+ if nextchar == '}':
+ return pairs, end + 1
+ if nextchar != '"':
+ raise ValueError(errmsg("Expecting property name", s, end))
+ end += 1
+ encoding = getattr(context, 'encoding', None)
+ while True:
+ key, end = scanstring(s, end, encoding)
+ end = _w(s, end).end()
+ if s[end:end + 1] != ':':
+ raise ValueError(errmsg("Expecting : delimiter", s, end))
+ end = _w(s, end + 1).end()
+ try:
+ value, end = JSONScanner.iterscan(s, idx=end).next()
+ except StopIteration:
+ raise ValueError(errmsg("Expecting object", s, end))
+ pairs[key] = value
+ end = _w(s, end).end()
+ nextchar = s[end:end + 1]
+ end += 1
+ if nextchar == '}':
+ break
+ if nextchar != ',':
+ raise ValueError(errmsg("Expecting , delimiter", s, end - 1))
+ end = _w(s, end).end()
+ nextchar = s[end:end + 1]
+ end += 1
+ if nextchar != '"':
+ raise ValueError(errmsg("Expecting property name", s, end - 1))
+ object_hook = getattr(context, 'object_hook', None)
+ if object_hook is not None:
+ pairs = object_hook(pairs)
+ return pairs, end
+pattern(r'{')(JSONObject)
+
+def JSONArray(match, context, _w=WHITESPACE.match):
+ values = []
+ s = match.string
+ end = _w(s, match.end()).end()
+ # look-ahead for trivial empty array
+ nextchar = s[end:end + 1]
+ if nextchar == ']':
+ return values, end + 1
+ while True:
+ try:
+ value, end = JSONScanner.iterscan(s, idx=end).next()
+ except StopIteration:
+ raise ValueError(errmsg("Expecting object", s, end))
+ values.append(value)
+ end = _w(s, end).end()
+ nextchar = s[end:end + 1]
+ end += 1
+ if nextchar == ']':
+ break
+ if nextchar != ',':
+ raise ValueError(errmsg("Expecting , delimiter", s, end))
+ end = _w(s, end).end()
+ return values, end
+pattern(r'\[')(JSONArray)
+
+ANYTHING = [
+ JSONObject,
+ JSONArray,
+ JSONString,
+ JSONConstant,
+ JSONNumber,
+]
+
+JSONScanner = Scanner(ANYTHING)
+
+class JSONDecoder(object):
+ """
+ Simple JSON <http://json.org> decoder
+
+ Performs the following translations in decoding:
+
+ +---------------+-------------------+
+ | JSON | Python |
+ +===============+===================+
+ | object | dict |
+ +---------------+-------------------+
+ | array | list |
+ +---------------+-------------------+
+ | string | unicode |
+ +---------------+-------------------+
+ | number (int) | int, long |
+ +---------------+-------------------+
+ | number (real) | float |
+ +---------------+-------------------+
+ | true | True |
+ +---------------+-------------------+
+ | false | False |
+ +---------------+-------------------+
+ | null | None |
+ +---------------+-------------------+
+
+ It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
+ their corresponding ``float`` values, which is outside the JSON spec.
+ """
+
+ _scanner = Scanner(ANYTHING)
+ __all__ = ['__init__', 'decode', 'raw_decode']
+
+ def __init__(self, encoding=None, object_hook=None):
+ """
+ ``encoding`` determines the encoding used to interpret any ``str``
+ objects decoded by this instance (utf-8 by default). It has no
+ effect when decoding ``unicode`` objects.
+
+ Note that currently only encodings that are a superset of ASCII work,
+ strings of other encodings should be passed in as ``unicode``.
+
+ ``object_hook``, if specified, will be called with the result
+ of every JSON object decoded and its return value will be used in
+ place of the given ``dict``. This can be used to provide custom
+ deserializations (e.g. to support JSON-RPC class hinting).
+ """
+ self.encoding = encoding
+ self.object_hook = object_hook
+
+ def decode(self, s, _w=WHITESPACE.match):
+ """
+ Return the Python representation of ``s`` (a ``str`` or ``unicode``
+ instance containing a JSON document)
+ """
+ obj, end = self.raw_decode(s, idx=_w(s, 0).end())
+ end = _w(s, end).end()
+ if end != len(s):
+ raise ValueError(errmsg("Extra data", s, end, len(s)))
+ return obj
+
+ def raw_decode(self, s, **kw):
+ """
+ Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning
+ with a JSON document) and return a 2-tuple of the Python
+ representation and the index in ``s`` where the document ended.
+
+ This can be used to decode a JSON document from a string that may
+ have extraneous data at the end.
+ """
+ kw.setdefault('context', self)
+ try:
+ obj, end = self._scanner.iterscan(s, **kw).next()
+ except StopIteration:
+ raise ValueError("No JSON object could be decoded")
+ return obj, end
+
+__all__ = ['JSONDecoder']
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/decoder.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/encoder.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/encoder.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/encoder.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,289 @@
+"""
+Implementation of JSONEncoder
+"""
+import re
+
+# this should match any kind of infinity
+INFCHARS = re.compile(r'[infINF]')
+ESCAPE = re.compile(r'[\x00-\x19\\"\b\f\n\r\t]')
+ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')
+ESCAPE_DCT = {
+ '\\': '\\\\',
+ '"': '\\"',
+ '\b': '\\b',
+ '\f': '\\f',
+ '\n': '\\n',
+ '\r': '\\r',
+ '\t': '\\t',
+}
+for i in range(20):
+ ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
+
+def floatstr(o, allow_nan=True):
+ s = str(o)
+ # If the first non-sign is a digit then it's not a special value
+ if (o < 0.0 and s[1].isdigit()) or s[0].isdigit():
+ return s
+ elif not allow_nan:
+ raise ValueError("Out of range float values are not JSON compliant: %r"
+ % (o,))
+ # These are the string representations on the platforms I've tried
+ if s == 'nan':
+ return 'NaN'
+ if s == 'inf':
+ return 'Infinity'
+ if s == '-inf':
+ return '-Infinity'
+ # NaN should either be inequal to itself, or equal to everything
+ if o != o or o == 0.0:
+ return 'NaN'
+ # Last ditch effort, assume inf
+ if o < 0:
+ return '-Infinity'
+ return 'Infinity'
+
+def encode_basestring(s):
+ """
+ Return a JSON representation of a Python string
+ """
+ def replace(match):
+ return ESCAPE_DCT[match.group(0)]
+ return '"' + ESCAPE.sub(replace, s) + '"'
+
+def encode_basestring_ascii(s):
+ def replace(match):
+ s = match.group(0)
+ try:
+ return ESCAPE_DCT[s]
+ except KeyError:
+ return '\\u%04x' % (ord(s),)
+ return '"' + str(ESCAPE_ASCII.sub(replace, s)) + '"'
+
+
+class JSONEncoder(object):
+ """
+ Extensible JSON <http://json.org> encoder for Python data structures.
+
+ Supports the following objects and types by default:
+
+ +-------------------+---------------+
+ | Python | JSON |
+ +===================+===============+
+ | dict | object |
+ +-------------------+---------------+
+ | list, tuple | array |
+ +-------------------+---------------+
+ | str, unicode | string |
+ +-------------------+---------------+
+ | int, long, float | number |
+ +-------------------+---------------+
+ | True | true |
+ +-------------------+---------------+
+ | False | false |
+ +-------------------+---------------+
+ | None | null |
+ +-------------------+---------------+
+
+ To extend this to recognize other objects, subclass and implement a
+ ``.default()`` method with another method that returns a serializable
+ object for ``o`` if possible, otherwise it should call the superclass
+ implementation (to raise ``TypeError``).
+ """
+ __all__ = ['__init__', 'default', 'encode', 'iterencode']
+ def __init__(self, skipkeys=False, ensure_ascii=True,
+ check_circular=True, allow_nan=True, sort_keys=False):
+ """
+ Constructor for JSONEncoder, with sensible defaults.
+
+ If skipkeys is False, then it is a TypeError to attempt
+ encoding of keys that are not str, int, long, float or None. If
+ skipkeys is True, such items are simply skipped.
+
+ If ensure_ascii is True, the output is guaranteed to be str
+ objects with all incoming unicode characters escaped. If
+ ensure_ascii is false, the output will be unicode object.
+
+ If check_circular is True, then lists, dicts, and custom encoded
+ objects will be checked for circular references during encoding to
+ prevent an infinite recursion (which would cause an OverflowError).
+ Otherwise, no such check takes place.
+
+ If allow_nan is True, then NaN, Infinity, and -Infinity will be
+ encoded as such. This behavior is not JSON specification compliant,
+ but is consistent with most JavaScript based encoders and decoders.
+ Otherwise, it will be a ValueError to encode such floats.
+
+ If sort_keys is True, then the output of dictionaries will be
+ sorted by key; this is useful for regression tests to ensure
+ that JSON serializations can be compared on a day-to-day basis.
+ """
+
+ self.skipkeys = skipkeys
+ self.ensure_ascii = ensure_ascii
+ self.check_circular = check_circular
+ self.allow_nan = allow_nan
+ self.sort_keys = sort_keys
+
+ def _iterencode_list(self, lst, markers=None):
+ if not lst:
+ yield '[]'
+ return
+ if markers is not None:
+ markerid = id(lst)
+ if markerid in markers:
+ raise ValueError("Circular reference detected")
+ markers[markerid] = lst
+ yield '['
+ first = True
+ for value in lst:
+ if first:
+ first = False
+ else:
+ yield ', '
+ for chunk in self._iterencode(value, markers):
+ yield chunk
+ yield ']'
+ if markers is not None:
+ del markers[markerid]
+
+ def _iterencode_dict(self, dct, markers=None):
+ if not dct:
+ yield '{}'
+ return
+ if markers is not None:
+ markerid = id(dct)
+ if markerid in markers:
+ raise ValueError("Circular reference detected")
+ markers[markerid] = dct
+ yield '{'
+ first = True
+ if self.ensure_ascii:
+ encoder = encode_basestring_ascii
+ else:
+ encoder = encode_basestring
+ allow_nan = self.allow_nan
+ if self.sort_keys:
+ keys = dct.keys()
+ keys.sort()
+ items = [(k,dct[k]) for k in keys]
+ else:
+ items = dct.iteritems()
+ for key, value in items:
+ if isinstance(key, basestring):
+ pass
+ # JavaScript is weakly typed for these, so it makes sense to
+ # also allow them. Many encoders seem to do something like this.
+ elif isinstance(key, float):
+ key = floatstr(key, allow_nan)
+ elif isinstance(key, (int, long)):
+ key = str(key)
+ elif key is True:
+ key = 'true'
+ elif key is False:
+ key = 'false'
+ elif key is None:
+ key = 'null'
+ elif self.skipkeys:
+ continue
+ else:
+ raise TypeError("key %r is not a string" % (key,))
+ if first:
+ first = False
+ else:
+ yield ', '
+ yield encoder(key)
+ yield ': '
+ for chunk in self._iterencode(value, markers):
+ yield chunk
+ yield '}'
+ if markers is not None:
+ del markers[markerid]
+
+ def _iterencode(self, o, markers=None):
+ if isinstance(o, basestring):
+ if self.ensure_ascii:
+ encoder = encode_basestring_ascii
+ else:
+ encoder = encode_basestring
+ yield encoder(o)
+ elif o is None:
+ yield 'null'
+ elif o is True:
+ yield 'true'
+ elif o is False:
+ yield 'false'
+ elif isinstance(o, (int, long)):
+ yield str(o)
+ elif isinstance(o, float):
+ yield floatstr(o, self.allow_nan)
+ elif isinstance(o, (list, tuple)):
+ for chunk in self._iterencode_list(o, markers):
+ yield chunk
+ elif isinstance(o, dict):
+ for chunk in self._iterencode_dict(o, markers):
+ yield chunk
+ else:
+ if markers is not None:
+ markerid = id(o)
+ if markerid in markers:
+ raise ValueError("Circular reference detected")
+ markers[markerid] = o
+ for chunk in self._iterencode_default(o, markers):
+ yield chunk
+ if markers is not None:
+ del markers[markerid]
+
+ def _iterencode_default(self, o, markers=None):
+ newobj = self.default(o)
+ return self._iterencode(newobj, markers)
+
+ def default(self, o):
+ """
+ Implement this method in a subclass such that it returns
+ a serializable object for ``o``, or calls the base implementation
+ (to raise a ``TypeError``).
+
+ For example, to support arbitrary iterators, you could
+ implement default like this::
+
+ def default(self, o):
+ try:
+ iterable = iter(o)
+ except TypeError:
+ pass
+ else:
+ return list(iterable)
+ return JSONEncoder.default(self, o)
+ """
+ raise TypeError("%r is not JSON serializable" % (o,))
+
+ def encode(self, o):
+ """
+ Return a JSON string representation of a Python data structure.
+
+ >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
+ '{"foo":["bar", "baz"]}'
+ """
+ # This doesn't pass the iterator directly to ''.join() because it
+ # sucks at reporting exceptions. It's going to do this internally
+ # anyway because it uses PySequence_Fast or similar.
+ chunks = list(self.iterencode(o))
+ return ''.join(chunks)
+
+ def iterencode(self, o):
+ """
+ Encode the given object and yield each string
+ representation as available.
+
+ For example::
+
+ for chunk in JSONEncoder().iterencode(bigobject):
+ mysocket.write(chunk)
+ """
+ if self.check_circular:
+ markers = {}
+ else:
+ markers = None
+ return self._iterencode(o, markers)
+
+__all__ = ['JSONEncoder']
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/encoder.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/jsonfilter.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/jsonfilter.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/jsonfilter.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,40 @@
+import simplejson
+import cgi
+
+class JSONFilter(object):
+ def __init__(self, app, mime_type='text/x-json'):
+ self.app = app
+ self.mime_type = mime_type
+
+ def __call__(self, environ, start_response):
+ # Read JSON POST input to jsonfilter.json if matching mime type
+ response = {'status': '200 OK', 'headers': []}
+ def json_start_response(status, headers):
+ response['status'] = status
+ response['headers'].extend(headers)
+ environ['jsonfilter.mime_type'] = self.mime_type
+ if environ.get('REQUEST_METHOD', '') == 'POST':
+ if environ.get('CONTENT_TYPE', '') == self.mime_type:
+ args = [_ for _ in [environ.get('CONTENT_LENGTH')] if _]
+ data = environ['wsgi.input'].read(*map(int, args))
+ environ['jsonfilter.json'] = simplejson.loads(data)
+ res = simplejson.dumps(self.app(environ, json_start_response))
+ jsonp = cgi.parse_qs(environ.get('QUERY_STRING', '')).get('jsonp')
+ if jsonp:
+ content_type = 'text/javascript'
+ res = ''.join(jsonp + ['(', res, ')'])
+ elif 'Opera' in environ.get('HTTP_USER_AGENT', ''):
+ # Opera has bunk XMLHttpRequest support for most mime types
+ content_type = 'text/plain'
+ else:
+ content_type = self.mime_type
+ headers = [
+ ('Content-type', content_type),
+ ('Content-length', len(res)),
+ ]
+ headers.extend(response['headers'])
+ start_response(response['status'], headers)
+ return [res]
+
+def factory(app, global_conf, **kw):
+ return JSONFilter(app, **kw)
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/jsonfilter.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/scanner.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/scanner.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/scanner.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,63 @@
+"""
+Iterator based sre token scanner
+"""
+import sre_parse, sre_compile, sre_constants
+from sre_constants import BRANCH, SUBPATTERN
+from sre import VERBOSE, MULTILINE, DOTALL
+import re
+
+__all__ = ['Scanner', 'pattern']
+
+FLAGS = (VERBOSE | MULTILINE | DOTALL)
+class Scanner(object):
+ def __init__(self, lexicon, flags=FLAGS):
+ self.actions = [None]
+ # combine phrases into a compound pattern
+ s = sre_parse.Pattern()
+ s.flags = flags
+ p = []
+ for idx, token in enumerate(lexicon):
+ phrase = token.pattern
+ try:
+ subpattern = sre_parse.SubPattern(s,
+ [(SUBPATTERN, (idx + 1, sre_parse.parse(phrase, flags)))])
+ except sre_constants.error:
+ raise
+ p.append(subpattern)
+ self.actions.append(token)
+
+ p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
+ self.scanner = sre_compile.compile(p)
+
+
+ def iterscan(self, string, idx=0, context=None):
+ """
+ Yield match, end_idx for each match
+ """
+ match = self.scanner.scanner(string, idx).match
+ actions = self.actions
+ lastend = idx
+ end = len(string)
+ while True:
+ m = match()
+ if m is None:
+ break
+ matchbegin, matchend = m.span()
+ if lastend == matchend:
+ break
+ action = actions[m.lastindex]
+ if action is not None:
+ rval, next_pos = action(m, context)
+ if next_pos is not None and next_pos != matchend:
+ # "fast forward" the scanner
+ matchend = next_pos
+ match = self.scanner.scanner(string, matchend).match
+ yield rval, matchend
+ lastend = matchend
+
+def pattern(pattern, flags=FLAGS):
+ def decorator(fn):
+ fn.pattern = pattern
+ fn.regex = re.compile(pattern, flags)
+ return fn
+ return decorator
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/scanner.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/__init__.py
===================================================================
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/__init__.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_fail.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_fail.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_fail.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,70 @@
+# Fri Dec 30 18:57:26 2005
+JSONDOCS = [
+ # http://json.org/JSON_checker/test/fail1.json
+ '"A JSON payload should be an object or array, not a string."',
+ # http://json.org/JSON_checker/test/fail2.json
+ '["Unclosed array"',
+ # http://json.org/JSON_checker/test/fail3.json
+ '{unquoted_key: "keys must be quoted}',
+ # http://json.org/JSON_checker/test/fail4.json
+ '["extra comma",]',
+ # http://json.org/JSON_checker/test/fail5.json
+ '["double extra comma",,]',
+ # http://json.org/JSON_checker/test/fail6.json
+ '[ , "<-- missing value"]',
+ # http://json.org/JSON_checker/test/fail7.json
+ '["Comma after the close"],',
+ # http://json.org/JSON_checker/test/fail8.json
+ '["Extra close"]]',
+ # http://json.org/JSON_checker/test/fail9.json
+ '{"Extra comma": true,}',
+ # http://json.org/JSON_checker/test/fail10.json
+ '{"Extra value after close": true} "misplaced quoted value"',
+ # http://json.org/JSON_checker/test/fail11.json
+ '{"Illegal expression": 1 + 2}',
+ # http://json.org/JSON_checker/test/fail12.json
+ '{"Illegal invocation": alert()}',
+ # http://json.org/JSON_checker/test/fail13.json
+ '{"Numbers cannot have leading zeroes": 013}',
+ # http://json.org/JSON_checker/test/fail14.json
+ '{"Numbers cannot be hex": 0x14}',
+ # http://json.org/JSON_checker/test/fail15.json
+ '["Illegal backslash escape: \\x15"]',
+ # http://json.org/JSON_checker/test/fail16.json
+ '["Illegal backslash escape: \\\'"]',
+ # http://json.org/JSON_checker/test/fail17.json
+ '["Illegal backslash escape: \\017"]',
+ # http://json.org/JSON_checker/test/fail18.json
+ '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]',
+ # http://json.org/JSON_checker/test/fail19.json
+ '{"Missing colon" null}',
+ # http://json.org/JSON_checker/test/fail20.json
+ '{"Double colon":: null}',
+ # http://json.org/JSON_checker/test/fail21.json
+ '{"Comma instead of colon", null}',
+ # http://json.org/JSON_checker/test/fail22.json
+ '["Colon instead of comma": false]',
+ # http://json.org/JSON_checker/test/fail23.json
+ '["Bad value", truth]',
+ # http://json.org/JSON_checker/test/fail24.json
+ "['single quote']",
+]
+
+SKIPS = {
+ 1: "why not have a string payload?",
+ 18: "spec doesn't specify any nesting limitations",
+}
+
+def test_failures():
+ import simplejson
+ for idx, doc in enumerate(JSONDOCS):
+ idx = idx + 1
+ if idx in SKIPS:
+ simplejson.loads(doc)
+ continue
+ try:
+ simplejson.loads(doc)
+ except ValueError:
+ pass
+ else:
+ assert False, "Expected failure for fail%d.json: %r" % (idx, doc)
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_fail.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass1.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass1.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass1.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,72 @@
+# from http://json.org/JSON_checker/test/pass1.json
+JSON = r'''
+[
+ "JSON Test Pattern pass1",
+ {"object with 1 member":["array with 1 element"]},
+ {},
+ [],
+ -42,
+ true,
+ false,
+ null,
+ {
+ "integer": 1234567890,
+ "real": -9876.543210,
+ "e": 0.123456789e-12,
+ "E": 1.234567890E+34,
+ "": 23456789012E666,
+ "zero": 0,
+ "one": 1,
+ "space": " ",
+ "quote": "\"",
+ "backslash": "\\",
+ "controls": "\b\f\n\r\t",
+ "slash": "/ & \/",
+ "alpha": "abcdefghijklmnopqrstuvwyz",
+ "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
+ "digit": "0123456789",
+ "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
+ "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
+ "true": true,
+ "false": false,
+ "null": null,
+ "array":[ ],
+ "object":{ },
+ "address": "50 St. James Street",
+ "url": "http://www.JSON.org/",
+ "comment": "// /* <!-- --",
+ "# -- --> */": " ",
+ " s p a c e d " :[1,2 , 3
+
+,
+
+4 , 5 , 6 ,7 ],
+ "compact": [1,2,3,4,5,6,7],
+ "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
+ "quotes": "" \u0022 %22 0x22 034 "",
+ "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
+: "A key can be any string"
+ },
+ 0.5 ,98.6
+,
+99.44
+,
+
+1066
+
+
+,"rosebud"]
+'''
+
+def test_parse():
+ # test in/out equivalence and parsing
+ import simplejson
+ res = simplejson.loads(JSON)
+ out = simplejson.dumps(res)
+ assert res == simplejson.loads(out)
+ try:
+ simplejson.dumps(res, allow_nan=False)
+ except ValueError:
+ pass
+ else:
+ assert False, "23456789012E666 should be out of range"
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass1.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass2.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass2.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass2.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,11 @@
+# from http://json.org/JSON_checker/test/pass2.json
+JSON = r'''
+[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]
+'''
+
+def test_parse():
+ # test in/out equivalence and parsing
+ import simplejson
+ res = simplejson.loads(JSON)
+ out = simplejson.dumps(res)
+ assert res == simplejson.loads(out)
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass2.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass3.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass3.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass3.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,16 @@
+# from http://json.org/JSON_checker/test/pass3.json
+JSON = r'''
+{
+ "JSON Test Pattern pass3": {
+ "The outermost value": "must be an object or array.",
+ "In this test": "It is an object."
+ }
+}
+'''
+
+def test_parse():
+ # test in/out equivalence and parsing
+ import simplejson
+ res = simplejson.loads(JSON)
+ out = simplejson.dumps(res)
+ assert res == simplejson.loads(out)
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_pass3.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_recursion.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_recursion.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_recursion.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,62 @@
+import simplejson
+
+def test_listrecursion():
+ x = []
+ x.append(x)
+ try:
+ simplejson.dumps(x)
+ except ValueError:
+ pass
+ else:
+ assert False, "didn't raise ValueError on list recursion"
+ x = []
+ y = [x]
+ x.append(y)
+ try:
+ simplejson.dumps(x)
+ except ValueError:
+ pass
+ else:
+ assert False, "didn't raise ValueError on alternating list recursion"
+ y = []
+ x = [y, y]
+ # ensure that the marker is cleared
+ simplejson.dumps(x)
+
+def test_dictrecursion():
+ x = {}
+ x["test"] = x
+ try:
+ simplejson.dumps(x)
+ except ValueError:
+ pass
+ else:
+ assert False, "didn't raise ValueError on dict recursion"
+ x = {}
+ y = {"a": x, "b": x}
+ # ensure that the marker is cleared
+ simplejson.dumps(x)
+
+class TestObject:
+ pass
+
+class RecursiveJSONEncoder(simplejson.JSONEncoder):
+ recurse = False
+ def default(self, o):
+ if o is TestObject:
+ if self.recurse:
+ return [TestObject]
+ else:
+ return 'TestObject'
+ simplejson.JSONEncoder.default(o)
+
+def test_defaultrecursion():
+ enc = RecursiveJSONEncoder()
+ assert enc.encode(TestObject) == '"TestObject"'
+ enc.recurse = True
+ try:
+ enc.encode(TestObject)
+ except ValueError:
+ pass
+ else:
+ assert False, "didn't raise ValueError on default recursion"
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/simplejson/tests/test_recursion.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Modified: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/browser.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/browser.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/browser.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -11,7 +11,7 @@
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
-"""Mechanize-based Functional Doctest interfaces
+"""Mechanize-based Functional Doctests
$Id$
"""
@@ -27,30 +27,14 @@
import sys
import time
import urllib2
+from zope.testbrowser.utilities import disambiguate, any, onlyOne, zeroOrOne, \
+ SetattrErrorsMixin, PystoneTimer, compressText, RegexType
try:
from zope import interface
except ImportError:
from dummymodules import interface
-RegexType = type(re.compile(''))
-_compress_re = re.compile(r"\s+")
-compressText = lambda text: _compress_re.sub(' ', text.strip())
-
-def disambiguate(intermediate, msg, index):
- if intermediate:
- if index is None:
- if len(intermediate) > 1:
- raise ClientForm.AmbiguityError(msg)
- else:
- return intermediate[0]
- else:
- try:
- return intermediate[index]
- except KeyError:
- msg = '%s index %d' % (msg, index)
- raise LookupError(msg)
-
def controlFactory(control, form, browser):
if isinstance(control, ClientForm.Item):
# it is a subcontrol
@@ -66,84 +50,7 @@
else:
return Control(control, form, browser)
-def any(items):
- return bool(sum([bool(i) for i in items]))
-def onlyOne(items, description):
- total = sum([bool(i) for i in items])
- if total == 0 or total > 1:
- raise ValueError(
- "Supply one and only one of %s as arguments" % description)
-
-def zeroOrOne(items, description):
- if sum([bool(i) for i in items]) > 1:
- raise ValueError(
- "Supply no more than one of %s as arguments" % description)
-
-
-class SetattrErrorsMixin(object):
- _enable_setattr_errors = False
-
- def __setattr__(self, name, value):
- if self._enable_setattr_errors:
- # cause an attribute error if the attribute doesn't already exist
- getattr(self, name)
-
- # set the value
- object.__setattr__(self, name, value)
-
-
-class PystoneTimer(object):
- start_time = 0
- end_time = 0
- _pystones_per_second = None
-
- @property
- def pystonesPerSecond(self):
- """How many pystones are equivalent to one second on this machine"""
- if self._pystones_per_second == None:
- self._pystones_per_second = pystone.pystones(pystone.LOOPS/10)[1]
- return self._pystones_per_second
-
- def _getTime(self):
- if sys.platform.startswith('win'):
- # Windows' time.clock gives us high-resolution wall-time
- return time.clock()
- else:
- # everyone else uses time.time
- return time.time()
-
- def start(self):
- """Begin a timing period"""
- self.start_time = self._getTime()
- self.end_time = None
-
- def stop(self):
- """End a timing period"""
- self.end_time = self._getTime()
-
- @property
- def elapsedSeconds(self):
- """Elapsed time from calling `start` to calling `stop` or present time
-
- If `stop` has been called, the timing period stopped then, otherwise
- the end is the current time.
- """
- if self.end_time is None:
- end_time = self._getTime()
- else:
- end_time = self.end_time
- return end_time - self.start_time
-
- @property
- def elapsedPystones(self):
- """Elapsed pystones in timing period
-
- See elapsed_seconds for definition of timing period.
- """
- return self.elapsedSeconds * self.pystonesPerSecond
-
-
class Browser(SetattrErrorsMixin):
"""A web user agent."""
interface.implements(interfaces.IBrowser)
Modified: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/interfaces.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/interfaces.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/interfaces.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -18,12 +18,18 @@
__docformat__ = "reStructuredText"
try:
- # zope.interface and zope.schema aren't included in the stand-alone version
- from zope import interface, schema
+ # zope.interface isn't included in the stand-alone version
+ from zope import interface
except ImportError:
- from dummymodules import interface, schema
+ from dummymodules import interface
+try:
+ # zope.schema isn't included in the stand-alone version
+ from zope import schema
+except ImportError:
+ from dummymodules import schema
+
class IBrowser(interface.Interface):
"""A Programmatic Web Browser."""
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remote.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remote.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remote.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,216 @@
+##############################################################################
+#
+# Copyright (c) 2005 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Browser-based Functional Doctests
+
+$Id$
+"""
+__docformat__ = "reStructuredText"
+from BeautifulSoup import BeautifulSoup
+from zope.testbrowser import interfaces
+from zope.testbrowser.remoteproxy2 import ServerManager, PROXY_PORT
+from zope.testbrowser.utilities import disambiguate, zeroOrOne, \
+ SetattrErrorsMixin, PystoneTimer
+import re
+import urlparse
+
+
+try:
+ from zope import interface
+except ImportError:
+ from dummymodules import interface
+
+def getTagText(soup):
+ text = str(soup)
+ text = re.sub('<[^>]*>', '', text)
+ text = re.sub(' +', ' ', text)
+ return text
+
+class Browser(SetattrErrorsMixin):
+ """A web user agent."""
+ interface.implements(interfaces.IBrowser)
+
+ _contents = None
+ _counter = 0
+
+ def __init__(self, url=None):
+ self.serverManager = ServerManager()
+ self.serverManager.start()
+ self.timer = PystoneTimer()
+ self._enable_setattr_errors = True
+
+ if url is not None:
+ self.open(url)
+
+ def close(self):
+ self.serverManager.stop()
+
+ @property
+ def url(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ return self.executeCommand('getUrl')
+
+ @property
+ def isHtml(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ raise NotImplemented
+
+ @property
+ def title(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ raise NotImplemented
+
+ @property
+ def contents(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ # XXX see note in commands.js
+ return self.executeCommand('getContents')
+
+ @property
+ def headers(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ raise NotImplemented
+
+ def handleErrors():
+ """See zope.testbrowser.interfaces.IBrowser"""
+ raise NotImplemented
+
+ def open(self, url, data=None):
+ """See zope.testbrowser.interfaces.IBrowser"""
+
+ (scheme, netloc, path, params, query, frag) = urlparse.urlparse(url)
+
+ if scheme != 'http':
+ self.send_error(400, "unknown scheme %r" % scheme)
+
+ url = urlparse.urlunparse(
+ (scheme, '192.168.0.113:%s' % PROXY_PORT, path, params, query, frag))
+
+ self._start_timer()
+ self.executeCommand('open', url, data)
+ self._stop_timer()
+ self._changed()
+
+ def executeCommand(self, command, *args):
+ """Execute a JavaScript routine on the client (not an official API)"""
+ return self.serverManager.executeCommand(command, *args)
+
+ def _start_timer(self):
+ self.timer.start()
+
+ def _stop_timer(self):
+ self.timer.stop()
+
+ @property
+ def lastRequestPystones(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ return self.timer.elapsedPystones
+
+ @property
+ def lastRequestSeconds(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ return self.timer.elapsedSeconds
+
+ def reload(self):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ self._start_timer()
+ self.executeCommand('reload')
+ self._stop_timer()
+ self._changed()
+
+ def goBack(self, count=1):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ self._start_timer()
+ self.executeCommand('goBack')
+ self._stop_timer()
+ self._changed()
+
+ def addHeader(self, key, value):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ raise NotImplemented
+
+ def getLink(self, text=None, url=None, id=None, index=None):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ soup = BeautifulSoup(self.contents)('a')
+ links = []
+
+ # "msg" holds the disambiguation message
+ # the Link instance below needs to know the index of the a tag (n)
+ if text is not None:
+ msg = 'text %r' % text
+ links = []
+ for n, a in enumerate(soup):
+ # remove all tags from the text in order to search it
+ if text in getTagText(a):
+ links.append((a, n))
+ elif url is not None:
+ msg = 'url %r' % text
+ for n, a in enumerate(soup):
+ if a['href'] == url:
+ links.append((a, n))
+ elif id is not None:
+ msg = 'id %r' % id
+ for n, a in enumerate(soup):
+ if a['id'] == id:
+ links.append((a, n))
+
+ link, n = disambiguate(links, msg, index)
+ return Link(link, n, self)
+
+ def getControl(self, label=None, name=None, index=None):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ raise NotImplemented
+
+ def getForm(self, id=None, name=None, action=None, index=None):
+ """See zope.testbrowser.interfaces.IBrowser"""
+ raise NotImplemented
+
+ def _changed(self):
+ self._counter += 1
+ self._contents = None
+
+
+class Link(SetattrErrorsMixin):
+ interface.implements(interfaces.ILink)
+
+ def __init__(self, link, index, browser):
+ self.link = link
+ self.browser = browser
+ self.url = urlparse.urljoin(self.browser.url, link['href'])
+ self._remembered_id = browser.executeCommand('rememberLinkN', index)
+ self._browser_counter = self.browser._counter
+ self._enable_setattr_errors = True
+
+ def click(self):
+ if self._browser_counter != self.browser._counter:
+ raise interfaces.ExpiredError
+ self.browser._start_timer()
+ self.browser.executeCommand('clickRememberedLink', self._remembered_id)
+ self.browser._stop_timer()
+ self.browser._changed()
+
+ @property
+ def text(self):
+ return getTagText(self.link)
+
+ @property
+ def tag(self):
+ return self.link.name
+
+ @property
+ def attrs(self):
+ return dict(self.link.attrs)
+
+ def __repr__(self):
+ return "<%s text=%r url=%r>" % (
+ self.__class__.__name__, self.text, self.url)
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remote.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remoteproxy.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remoteproxy.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remoteproxy.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,208 @@
+import BaseHTTPServer
+import Queue
+import SocketServer
+import cgi
+import httplib
+import os
+import select
+import simplejson
+import socket
+import threading
+import urlparse
+
+base_dir = '/home/benji/workspace/testbrowser'
+allowed_resources = ['MochiKit', 'shim.js', 'commands.js', 'start.html']
+PROXY_PORT = 8000
+
+class Constant(object):
+ def __init__(self, name):
+ self.name = name
+
+ def __str__(self):
+ return self.name
+
+UNDEFINED = Constant('undefined')
+
+class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+# server_version = "TinyHTTPProxy/" + __version__
+ rbufsize = 0
+ remote_host = 'localhost:8080' # TODO needs to be configurable
+
+ def __init__(self, request, client_address, server):
+ self.command_queue = server.command_queue
+ self.result_queue = server.result_queue
+ BaseHTTPServer.BaseHTTPRequestHandler.__init__(
+ self, request, client_address, server)
+
+ def _connect(self, netloc, soc):
+ if ':' in netloc:
+ i = netloc.index(':')
+ host_and_port = netloc[:i], int(netloc[i+1:])
+ else:
+ host_and_port = netloc, 80
+ try:
+ soc.connect(host_and_port)
+ except socket.error, arg:
+ try:
+ msg = arg[1]
+ except:
+ msg = arg
+ self.send_error(404, msg)
+ return False
+ return True
+
+# def do_CONNECT(self):
+# soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+# try:
+# if self._connect(self.path, soc):
+# self.log_request(200)
+# self.wfile.write(self.protocol_version +
+# " 200 Connection established\r\n")
+# self.wfile.write("\r\n")
+# self._read_write(soc, 300)
+# finally:
+# soc.close()
+# self.connection.close()
+
+ def sendFile(self, path):
+ assert path.startswith('/')
+ path = path[1:]
+ assert path.split('/')[1] in allowed_resources
+ # XXX might use too much memory
+ self.wfile.write(open(os.path.join(base_dir, path)).read())
+
+ def handleRequest(self):
+ (scheme, netloc, path, params, query, fragment) = urlparse.urlparse(
+ self.path, 'http')
+ assert netloc == ''
+ print self.path
+ if scheme != 'http':
+ self.send_error(400, "unknown scheme %r" % scheme)
+ return
+ self.log_request()
+
+ if self.command in ('GET', 'POST'):
+ if path.startswith('/__resources__/'):
+ self.sendFile(path)
+ return
+ elif path.startswith('/__api__/'):
+ operation = urlparse.urlparse(self.path)[2].split('/')[-1]
+ raw_json = self.rfile.next()
+
+ if raw_json.strip() == 'undefined':
+ last_result = UNDEFINED
+ else:
+ last_result = simplejson.loads(raw_json)
+
+ if operation == 'next':
+ # if no command has been processed yet, the last_result
+ # value will be a placeholder
+ if last_result != '__testbrowser__no_result_yet':
+ self.result_queue.put(last_result)
+
+ response = self.command_queue.get()
+ if response[0] == '_tb_stop':
+ self.server.stop = True
+ self.result_queue.put('the server has stopped')
+ else:
+ self.send_response(404)
+ self.send_header('Content-Type', 'text/plain')
+ self.end_headers()
+ msg = 'unknown operation: %r' % operation
+ self.wfile.write(msg)
+ raise RuntimeError(msg)
+
+ self.send_response(200)
+ self.send_header('Content-Type', 'text/plain')
+ self.end_headers()
+ self.wfile.write(simplejson.dumps(response))
+ return
+
+ soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ try:
+ print 'sending', self.remote_host
+ if self._connect(self.remote_host, soc):
+ soc.send("%s %s %s\r\n" % (
+ self.command,
+ urlparse.urlunparse(('', '', path, params, query, '')),
+ self.request_version))
+ self.headers['Connection'] = 'close'
+
+ for key_val in self.headers.items():
+ soc.send("%s: %s\r\n" % key_val)
+ soc.send("\r\n")
+ self._read_write(soc)
+ print 'done with', self.path
+ finally:
+ soc.close()
+ self.connection.close()
+
+ def _read_write(self, soc, max_idling=20):
+ iw = [self.connection, soc]
+ count = 0
+ while 1:
+ count += 1
+ (iwtd, _, ewtd) = select.select(iw, [], iw, 3)
+ if ewtd:
+ break
+ if iwtd:
+ for i in iwtd:
+ if i is soc:
+ out = self.connection
+ else:
+ out = soc
+ data = i.recv(8192)
+
+ if data:
+ out.send(data)
+ count = 0
+
+ if count == max_idling:
+ break
+
+ do_HEAD = do_POST = do_PUT = do_DELETE = do_GET = handleRequest
+
+ def do_NOOP(self):
+ self.send_response(200)
+ self.end_headers()
+
+ def log_message(self, format, *args):
+ pass
+
+
+class HttpServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
+
+ stop = False
+
+ def __init__(self, *args, **kws):
+ self.command_queue = Queue.Queue()
+ self.result_queue = Queue.Queue()
+ BaseHTTPServer.HTTPServer.__init__(self, *args, **kws)
+
+ def serve_forever(self):
+ """Handle one request at a time until stopped."""
+ while not self.stop:
+ self.handle_request()
+
+
+class ServerManager(object):
+ def __init__(self):
+ self.port = PROXY_PORT
+ self.server = HttpServer(('0.0.0.0', self.port), RequestHandler)
+
+ def start(self):
+ self.server_thread = threading.Thread(
+ target=self.server.serve_forever)
+ self.server_thread.setDaemon(True)
+ self.server_thread.start()
+
+ def stop(self):
+ self.executeCommand('stop')
+ conn = httplib.HTTPConnection('localhost:%d' % self.port)
+ conn.request('NOOP', '/')
+ conn.getresponse()
+ self.server_thread.join()
+
+ def executeCommand(self, command, *args):
+ self.server.command_queue.put( ('_tb_'+command, simplejson.dumps(args)) )
+ return self.server.result_queue.get()
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/remoteproxy.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Modified: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/tests.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/tests.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/tests.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -47,7 +47,7 @@
class FauxConnection(object):
- """A ``urllib2`` compatible connection object."""
+ """A ``urllib2`` compatible connection obejct."""
def __init__(self, host):
pass
@@ -89,7 +89,7 @@
def getresponse(self):
"""Return a ``urllib2`` compatible response.
- The goal of this method is to convert the Zope Publisher's response to
+ The goal of ths method is to convert the Zope Publisher's reseponse to
a ``urllib2`` compatible response, which is also understood by
mechanize.
"""
@@ -160,7 +160,7 @@
def test_file_upload():
"""
-
+
>>> browser = Browser()
When given a form with a file-upload
@@ -195,7 +195,7 @@
--127.0.0.11000318041146699896411--
<BLANKLINE>
-You can pass a string to add_file:
+You can pass s atring to add_file:
>>> browser.getControl(name='foo').add_file(
@@ -220,8 +220,7 @@
"""
checker = renormalizing.RENormalizing([
- (re.compile(r'^--\S+\.\S+\.\S+', re.M), '-'*30),
- (re.compile(r'boundary=\S+\.\S+\.\S+'), 'boundary='+'-'*30),
+ (re.compile('127.0.0.\S+'), '-'*30),
(re.compile('User-agent:\s+\S+'), 'User-agent: XXX'),
(re.compile('Content-length:\s+\S+'), 'Content-length: 123'),
])
Added: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/utilities.py
===================================================================
--- Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/utilities.py 2006-06-01 02:16:36 UTC (rev 68419)
+++ Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/utilities.py 2006-06-01 03:20:48 UTC (rev 68420)
@@ -0,0 +1,120 @@
+##############################################################################
+#
+# Copyright (c) 2005 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Utilities used by the package
+
+$Id$
+"""
+__docformat__ = "reStructuredText"
+
+import re
+import sys
+import time
+
+class AmbiguityError(KeyError):
+ pass
+
+RegexType = type(re.compile(''))
+_compress_re = re.compile(r"\s+")
+compressText = lambda text: _compress_re.sub(' ', text.strip())
+
+def disambiguate(intermediate, msg, index):
+ if intermediate:
+ if index is None:
+ if len(intermediate) > 1:
+ raise AmbiguityError(msg)
+ else:
+ return intermediate[0]
+ else:
+ try:
+ return intermediate[index]
+ except KeyError:
+ msg = '%s index %d' % (msg, index)
+ raise LookupError(msg)
+
+def any(items):
+ return bool(sum([bool(i) for i in items]))
+
+def onlyOne(items, description):
+ total = sum([bool(i) for i in items])
+ if total == 0 or total > 1:
+ raise ValueError(
+ "Supply one and only one of %s as arguments" % description)
+
+def zeroOrOne(items, description):
+ if sum([bool(i) for i in items]) > 1:
+ raise ValueError(
+ "Supply no more than one of %s as arguments" % description)
+
+
+class SetattrErrorsMixin(object):
+ _enable_setattr_errors = False
+
+ def __setattr__(self, name, value):
+ if self._enable_setattr_errors:
+ # cause an attribute error if the attribute doesn't already exist
+ getattr(self, name)
+
+ # set the value
+ object.__setattr__(self, name, value)
+
+
+class PystoneTimer(object):
+ start_time = 0
+ end_time = 0
+ _pystones_per_second = None
+
+ @property
+ def pystonesPerSecond(self):
+ """How many pystones are equivalent to one second on this machine"""
+ if self._pystones_per_second == None:
+ self._pystones_per_second = pystone.pystones(pystone.LOOPS/10)[1]
+ return self._pystones_per_second
+
+ def _getTime(self):
+ if sys.platform.startswith('win'):
+ # Windows' time.clock gives us high-resolution wall-time
+ return time.clock()
+ else:
+ # everyone else uses time.time
+ return time.time()
+
+ def start(self):
+ """Begin a timing period"""
+ self.start_time = self._getTime()
+ self.end_time = None
+
+ def stop(self):
+ """End a timing period"""
+ self.end_time = self._getTime()
+
+ @property
+ def elapsedSeconds(self):
+ """Elapsed time from calling `start` to calling `stop` or present time
+
+ If `stop` has been called, the timing period stopped then, otherwise
+ the end is the current time.
+ """
+ if self.end_time is None:
+ end_time = self._getTime()
+ else:
+ end_time = self.end_time
+ return end_time - self.start_time
+
+ @property
+ def elapsedPystones(self):
+ """Elapsed pystones in timing period
+
+ See elapsed_seconds for definition of timing period.
+ """
+ return self.elapsedSeconds * self.pystonesPerSecond
Property changes on: Zope3/branches/benji-testbrowser-with-real-browsers/src/zope/testbrowser/utilities.py
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
More information about the Zope3-Checkins
mailing list