All Profiles
3 | 4 || URL | 7 |Cost | 8 |Time | 9 |Profile ID | 10 |11 | |
|---|---|---|---|---|
| ${environ['SCRIPT_NAME'] + environ['PATH_INFO'] + environ['QUERY_STRING']|h} | 28 |\
29 | \
30 | ${total_cost} ms\
31 | \
32 | \
33 | |
34 | ${'%i' % int(now-created_time)} seconds ago | 35 |${profile_id} | 36 |delete | 37 |
| Error | 42 |Time | 43 |Profile ID | 44 |45 | | |
| ${error|h} | 49 |${'%i' % int(now-created_time)} seconds ago | 50 |${profile_id} | 51 |delete | 52 ||
6 |
40 |
41 | <%def name="show_node(node, depth, tottime, callcount=1)">
42 | <%
43 | import random
44 | parent_id = ''.join([str(random.randrange(0,10)) for x in range(0,9)])
45 | child_nodes = [x for x in node['calls'] if not x['builtin']]
46 | has_children = len(child_nodes) > 0
47 | if int(float(tottime)) == 0:
48 | proj_width = 1
49 | else:
50 | factor = float(400) / float(tottime)
51 | proj_width = int(float(factor) * float(node['cost']))
52 | %>
53 | % if has_children:
54 | Viewing profile ID: ${id}
7 | 8 |URL
9 | 10 |${environ['SCRIPT_NAME'] + environ['PATH_INFO'] + environ['QUERY_STRING']|h}
11 |
12 | Environment
13 | 14 | 24 | 25 |Profile
26 |\
27 |
39 | -
28 | % for node in profile:
29 | <%
30 | if "disable' of '_lsprof.Profiler" in node['function']:
31 | continue
32 | if '
-
59 |
${node['cost']}ms 60 | % if callcount > 1: 61 | ✕${callcount} 62 | % endif 63 | % if has_children: 64 | \ 65 | ${node['func_name']|h}\ 66 | % else: 67 | ${node['func_name']|h}\ 68 | % endif 69 |
70 |
76 | - 77 |
',
105 | tb_formatter=lambda tb: '')
106 | resp = app.get('/error')
107 | print(resp) # for debugging
108 | self.assertIn('hello, world!', resp)
109 | self.assertIn('
&1`" || { echo; echo "Your working tree is not clean:" 1>&2; $(VCS_STATUS) 1>&2; exit 1; }
72 | endif
73 |
74 | # NB: do not use $(MAKE) in rules with multiple shell commands joined by &&
75 | # because then make -n distcheck will actually run those instead of just
76 | # printing what it does
77 |
78 | # TBH this could (and probably should) be replaced by check-manifest
79 |
80 | .PHONY: distcheck-sdist
81 | distcheck-sdist: dist
82 | pkg_and_version=`$(PYTHON) setup.py --name|tr A-Z.- a-z__`-`$(PYTHON) setup.py --version` && \
83 | rm -rf tmp && \
84 | mkdir tmp && \
85 | $(VCS_EXPORT) && \
86 | cd tmp && \
87 | tar -xzf ../dist/$$pkg_and_version.tar.gz && \
88 | diff -ur $$pkg_and_version tree $(DISTCHECK_DIFF_OPTS) && \
89 | cd $$pkg_and_version && \
90 | make dist check && \
91 | cd .. && \
92 | mkdir one two && \
93 | cd one && \
94 | tar -xzf ../../dist/$$pkg_and_version.tar.gz && \
95 | cd ../two/ && \
96 | tar -xzf ../$$pkg_and_version/dist/$$pkg_and_version.tar.gz && \
97 | cd .. && \
98 | diff -ur one two -x SOURCES.txt -I'^#:' && \
99 | cd .. && \
100 | rm -rf tmp && \
101 | echo "sdist seems to be ok"
102 |
103 | .PHONY: check-latest-rules
104 | check-latest-rules:
105 | ifndef FORCE
106 | @curl -s $(LATEST_RELEASE_MK_URL) | cmp -s release.mk || { printf "\nYour release.mk does not match the latest version at\n$(LATEST_RELEASE_MK_URL)\n\n" 1>&2; exit 1; }
107 | endif
108 |
109 | .PHONY: check-latest-version
110 | check-latest-version:
111 | $(VCS_GET_LATEST)
112 |
113 | .PHONY: check-version-number
114 | check-version-number:
115 | @$(PYTHON) setup.py --version | grep -qv dev || { \
116 | echo "Please remove the 'dev' suffix from the version number in $(FILE_WITH_VERSION)"; exit 1; }
117 |
118 | .PHONY: check-long-description
119 | check-long-description:
120 | @$(PYTHON) setup.py --long-description | rst2html --exit-status=2 > /dev/null
121 |
122 | .PHONY: check-changelog
123 | check-changelog:
124 | @ver_and_date="$(CHANGELOG_FORMAT)" && \
125 | grep -q "^$$ver_and_date$$" $(FILE_WITH_CHANGELOG) || { \
126 | echo "$(FILE_WITH_CHANGELOG) has no entry for $$ver_and_date"; exit 1; }
127 |
128 |
129 | # NB: the Makefile that includes release.mk may want to add additional
130 | # dependencies to the releasechecklist target, but I want 'make distcheck' to
131 | # happen last, so that's why I put it into the recipe and not at the end of the
132 | # list of dependencies.
133 |
134 | .PHONY: releasechecklist
135 | releasechecklist: check-latest-rules check-latest-version check-version-number check-long-description check-changelog
136 | $(MAKE) distcheck
137 |
138 | .PHONY: release
139 | release: releasechecklist do-release ##: prepare a new PyPI release
140 |
141 | .PHONY: do-release
142 | do-release:
143 | $(release_recipe)
144 |
145 | define default_release_recipe_publish_and_tag =
146 | # I'm chicken so I won't actually do these things yet
147 | @echo "Please run"
148 | @echo
149 | @echo " $(PYPI_PUBLISH)"
150 | @echo " $(VCS_TAG)"
151 | @echo
152 | endef
153 | define default_release_recipe_increment_and_push =
154 | @echo "Please increment the version number in $(FILE_WITH_VERSION)"
155 | @echo "and add a new empty entry at the top of the changelog in $(FILE_WITH_CHANGELOG), then"
156 | @echo
157 | @echo ' $(VCS_COMMIT_AND_PUSH)'
158 | @echo
159 | endef
160 | ifndef release_recipe
161 | define release_recipe =
162 | $(default_release_recipe_publish_and_tag)
163 | $(default_release_recipe_increment_and_push)
164 | endef
165 | endif
166 |
--------------------------------------------------------------------------------
/dozer/tests/test_reftree.py:
--------------------------------------------------------------------------------
1 | import gc
2 | import unittest
3 | from io import StringIO
4 | from unittest.mock import patch
5 |
6 | from dozer.reftree import (
7 | CircularReferents,
8 | ReferentTree,
9 | ReferrerTree,
10 | Tree,
11 | count_objects,
12 | get_repr,
13 | repr_dict,
14 | repr_set,
15 | )
16 |
17 |
18 | class TestTree(unittest.TestCase):
19 |
20 | def test_walk_max_results(self):
21 | tree = Tree(None, None)
22 | tree._gen = lambda x: list(range(20))
23 | res = list(tree.walk(maxresults=3))
24 | self.assertEqual(res,
25 | [0, 1, 2, (0, 0, "==== Max results reached ====")])
26 |
27 | def test_print_tree(self):
28 | tree = Tree(None, None)
29 | tree._gen = lambda x: [(0, 12345, 'ref1'), (1, 23456, 'ref2')]
30 | with patch('sys.stdout', StringIO()) as stdout:
31 | tree.print_tree()
32 | self.assertEqual(stdout.getvalue(),
33 | " 12345 ref1\n"
34 | " 23456 ref2\n")
35 |
36 |
37 | class MyObj(object):
38 |
39 | def __init__(self, **kw):
40 | self.__dict__.update(kw)
41 |
42 | def __repr__(self):
43 | return getattr(self, 'name', 'unnamed-MyObj')
44 |
45 |
46 | class Unrepresentable(object):
47 | def __repr__(self):
48 | raise Exception('haha you cannot represent me')
49 |
50 |
51 | class TestGlobals(unittest.TestCase):
52 |
53 | def test_repr_dict_unsortable(self):
54 | repr_dict({int: 'int', str: 'str'})
55 |
56 | def test_repr_set_unsortable(self):
57 | repr_set({int, str})
58 |
59 | def test_get_repr_unrepresentable(self):
60 | # repr(Exception('foo')) is "Exception('foo',)" on Python < 3.7
61 | # repr(Exception('foo')) is "Exception('foo')" on Python >= 3.7
62 | self.assertEqual(
63 | get_repr(Unrepresentable()).replace(',)', ')'),
64 | "unrepresentable object: Exception('haha you cannot represent me')")
65 |
66 | def test_count_objects(self):
67 | gc.collect()
68 | obj = MyObj()
69 | res = count_objects()
70 | self.assertIn((1, MyObj), [(n, c) for (n, c) in res if c is MyObj])
71 |
72 |
73 | class TestReferentTree(unittest.TestCase):
74 |
75 | def make_tree(self):
76 | tree = ReferentTree(None, None)
77 | tree.maxdepth = 10
78 | tree.seen = {}
79 | return tree
80 |
81 | def test_gen(self):
82 | tree = self.make_tree()
83 | ref = MyObj(name='b')
84 | other = MyObj(name='c')
85 | obj = MyObj(name='a', ref=ref, other=other, again=other)
86 | tree.ignore(ref)
87 | res = list(tree._gen(obj))
88 | # ref is found either at depth 0 or depth 1, depending on Python
89 | # version, because Pyton 3.13 optimizes __dict__ away and a direct
90 | # reference
91 | self.assertTrue(
92 | (0, id(other), 'c') in res or (1, id(other), 'c') in res
93 | )
94 | self.assertTrue(
95 | (0, id(other), '!c') in res or (1, id(other), '!c') in res
96 | )
97 |
98 |
99 | class TestReferrerTree(unittest.TestCase):
100 |
101 | def make_tree(self, maxdepth=10):
102 | tree = ReferrerTree(None, None)
103 | tree.maxdepth = maxdepth
104 | tree.seen = {}
105 | return tree
106 |
107 | def test_gen(self):
108 | tree = self.make_tree()
109 | obj = MyObj()
110 | ref = MyObj(name='a', obj=obj)
111 | res = list(tree._gen(obj))
112 | # ref is found either at depth 0 or depth 1, depending on Python
113 | # version, because Pyton 3.13 optimizes __dict__ away and a direct
114 | # reference
115 | self.assertTrue((0, id(ref), 'a') in res or (1, id(ref), 'a') in res)
116 |
117 | def test_gen_maxdepth(self):
118 | tree = self.make_tree(maxdepth=1)
119 | obj = MyObj()
120 | # On Python 3.7 the local code frame is somehow not counted
121 | # as a referer! So we need to create at least one more reference.
122 | ref = MyObj(name='a', obj=obj) # noqa
123 | res = list(tree._gen(obj))
124 | self.assertIn((1, 0, "---- Max depth reached ----"), res)
125 |
126 |
127 | class TestCircularReferents(unittest.TestCase):
128 |
129 | def make_tree(self, obj=None):
130 | tree = CircularReferents(obj, None)
131 | return tree
132 |
133 | def make_cycle(self):
134 | obj = MyObj(name='obj',
135 | a=MyObj(name='a', c=MyObj(name='c')),
136 | b=MyObj(name='b'))
137 | obj.b.obj = obj # make a cycle
138 | return obj
139 |
140 | def test_walk(self):
141 | obj = self.make_cycle()
142 | tree = self.make_tree(obj)
143 | res = list(tree.walk())
144 | self.assertEqual(len(res), 1) # one cycle
145 | # Python 3.11 introduced lazy object namespaces where obj.__dict__
146 | # gets created only on access, so the cycle might be MyObj -> MyObj
147 | # or it might be MyObj -> __dict__ -> MyObj -> __dict__, depending
148 | # on Python version and on whether MyObj.__dict__ was ever accessed.
149 | # Python 3.13 never actually treats the __dict__ as a separate object.
150 | self.assertIn(len(res[0]), (2, 4))
151 |
152 | def test_walk_maxresults(self):
153 | obj = self.make_cycle()
154 | tree = self.make_tree(obj)
155 | res = list(tree.walk(maxresults=1))
156 | self.assertIn((0, 0, "==== Max results reached ===="), res)
157 |
158 | def test_walk_maxdepth(self):
159 | obj = self.make_cycle()
160 | tree = self.make_tree(obj)
161 | res = list(tree.walk(maxdepth=2))
162 | self.assertGreater(tree.stops, 0)
163 |
164 | def test_print_tree(self):
165 | obj = self.make_cycle()
166 | tree = self.make_tree(obj)
167 | with patch('sys.stdout', StringIO()) as stdout:
168 | tree.print_tree(maxdepth=5)
169 | self.assertIn(
170 | stdout.getvalue(),
171 | (
172 | # Python 3.10--3.12: each __dict__ shown separately
173 | '''["dict of len 3: {'a': a, 'b': b, 'name': 'obj'}", 'b','''
174 | ''' "dict of len 2: {'name': 'b', 'obj': obj}", 'obj']\n'''
175 | '''2 paths stopped because max depth reached\n''',
176 | # Python 3.13: the __dict__s are optimized away
177 | '''['b', 'obj']\n'''
178 | '''9 paths stopped because max depth reached\n''',
179 | ),
180 | )
181 |
--------------------------------------------------------------------------------
/dozer/templates/logbar.mako:
--------------------------------------------------------------------------------
1 | <%!
2 | import time
3 | converter = time.localtime
4 | def format_time(record, start, prev_record=None):
5 | if prev_record:
6 | delta_from_prev = (record.created - prev_record.created) * 1000
7 | return '%+dms' % delta_from_prev
8 | else:
9 | time_from_start = (record.created - start) * 1000
10 | return '%+dms' % time_from_start
11 |
12 | def bg_color(event, log_colors):
13 | if event.name in log_colors:
14 | return log_colors[event.name]
15 | for key in log_colors:
16 | if event.name.startswith(key):
17 | return log_colors[key]
18 | return '#fff'
19 |
20 | def fg_color(frame, traceback_colors):
21 | for key in traceback_colors:
22 | if key in frame:
23 | return traceback_colors[key]
24 | return None
25 | %>
26 |
27 | ', resp)
150 |
151 | def test_profiler_index_empty(self):
152 | app = self.make_test_app()
153 | resp = app.get('/_profiler')
154 | self.assertEqual(resp.status_int, 200)
155 | self.assertIn('', resp)
156 |
157 | def test_profiler_broken_pickle(self):
158 | app = self.make_test_app()
159 | self.save_fake_profile(42, b'not a pickle at all')
160 | resp = app.get('/_profiler')
161 | self.assertEqual(resp.status_int, 200)
162 | self.assertIn('', resp)
163 |
164 | def test_profiler_empty_profile(self):
165 | app = self.make_test_app()
166 | self.save_fake_profile(42, pickle.dumps(dict(
167 | environ={'SCRIPT_NAME': '', 'PATH_INFO': '/', 'QUERY_STRING': ''},
168 | profile={},
169 | )))
170 | resp = app.get('/_profiler')
171 | self.assertEqual(resp.status_int, 200)
172 | self.assertIn('', resp)
173 |
174 | def test_profiler_not_found(self):
175 | app = self.make_test_app()
176 | app.get('/_profiler/nosuchpage', status=404)
177 |
178 | def test_profiler_forbidden(self):
179 | app = self.make_test_app()
180 | app.get('/_profiler/profiler', status=403)
181 |
182 | def test_profiler_media(self):
183 | app = self.make_test_app()
184 | resp = app.get('/_profiler/media/css/profile.css')
185 | self.assertEqual(resp.status_int, 200)
186 | self.assertEqual(resp.content_type, 'text/css')
187 | self.assertIn('#profile {', resp)
188 |
189 | def test_profiler_show_no_id(self):
190 | app = self.make_test_app()
191 | app.get('/_profiler/show', status=404)
192 |
193 | def test_profiler_show(self):
194 | app = self.make_test_app()
195 | prof_id = self.record_profile(app)
196 | resp = app.get('/_profiler/show/%s' % prof_id)
197 | self.assertIn('
28 |
114 |
153 |
--------------------------------------------------------------------------------
/dozer/reftree.py:
--------------------------------------------------------------------------------
1 | import gc
2 | import sys
3 | from operator import itemgetter
4 | from types import FrameType
5 |
6 |
7 | class Tree(object):
8 |
9 | def __init__(self, obj, req):
10 | self.req = req
11 | self.obj = obj
12 | self.filename = sys._getframe().f_code.co_filename
13 | self._ignore = {}
14 |
15 | def ignore(self, *objects):
16 | for obj in objects:
17 | self._ignore[id(obj)] = None
18 |
19 | def ignore_caller(self):
20 | f = sys._getframe() # = this function
21 | cur = f.f_back # = the function that called us (probably 'walk')
22 | self.ignore(cur, cur.f_builtins, cur.f_locals, cur.f_globals)
23 | caller = f.f_back # = the 'real' caller
24 | self.ignore(caller, caller.f_builtins, caller.f_locals, caller.f_globals)
25 |
26 | def walk(self, maxresults=100, maxdepth=None):
27 | """Walk the object tree, ignoring duplicates and circular refs."""
28 | self.seen = {}
29 | self.ignore(self, self.__dict__, self.obj, self.seen, self._ignore)
30 |
31 | # Ignore the calling frame, its builtins, globals and locals
32 | self.ignore_caller()
33 |
34 | self.maxdepth = maxdepth
35 | count = 0
36 | for result in self._gen(self.obj):
37 | yield result
38 | count += 1
39 | if maxresults and count >= maxresults:
40 | yield 0, 0, "==== Max results reached ===="
41 | return
42 |
43 | def print_tree(self, maxresults=100, maxdepth=None):
44 | """Walk the object tree, pretty-printing each branch."""
45 | self.ignore_caller()
46 | for depth, refid, rep in self.walk(maxresults, maxdepth):
47 | print("%9d %s %s" % (refid, " " * (depth * 2), rep))
48 |
49 |
50 | def try_sorted(thing):
51 | try:
52 | return sorted(thing)
53 | except TypeError: # pragma: PY3
54 | return thing
55 |
56 |
57 | def repr_dict(obj):
58 | return "dict of len %s: {%s}" % (len(obj), ", ".join(
59 | "%s: %s" % (repr(k), repr(v)) for k, v in try_sorted(obj.items())))
60 |
61 |
62 | def repr_set(obj):
63 | return "set of len %s: set([%s])" % (len(obj), ", ".join(
64 | map(repr, try_sorted(obj))))
65 |
66 |
67 | def _repr_container(obj):
68 | return "%s of len %s: %r" % (type(obj).__name__, len(obj), obj)
69 |
70 |
71 | repr_list = _repr_container
72 | repr_tuple = _repr_container
73 |
74 |
75 | def repr_str(obj):
76 | return "%s of len %s: %r" % (type(obj).__name__, len(obj), obj)
77 |
78 |
79 | repr_unicode = repr_str
80 |
81 |
82 | def repr_frame(obj):
83 | return "frame from %s line %s" % (obj.f_code.co_filename, obj.f_lineno)
84 |
85 |
86 | def get_repr(obj, limit=250):
87 | typename = getattr(type(obj), "__name__", None)
88 | handler = globals().get("repr_%s" % typename, repr)
89 |
90 | try:
91 | result = handler(obj)
92 | except Exception as e:
93 | result = "unrepresentable object: %r" % e
94 |
95 | if len(result) > limit:
96 | result = result[:limit] + "..."
97 |
98 | return result
99 |
100 |
101 | class ReferentTree(Tree):
102 |
103 | def _gen(self, obj, depth=0):
104 | if self.maxdepth and depth >= self.maxdepth:
105 | yield depth, 0, "---- Max depth reached ----"
106 | return
107 |
108 | for ref in gc.get_referents(obj):
109 | if id(ref) in self._ignore:
110 | continue
111 | elif id(ref) in self.seen:
112 | yield depth, id(ref), "!" + get_repr(ref)
113 | continue
114 | else:
115 | self.seen[id(ref)] = None
116 | yield depth, id(ref), get_repr(ref)
117 |
118 | for child in self._gen(ref, depth + 1):
119 | yield child
120 |
121 |
122 | class ReferrerTree(Tree):
123 |
124 | def _gen(self, obj, depth=0):
125 | if self.maxdepth and depth >= self.maxdepth:
126 | yield depth, 0, "---- Max depth reached ----"
127 | return
128 |
129 | refs = gc.get_referrers(obj)
130 | refiter = iter(refs)
131 | self.ignore(refs, refiter)
132 | for ref in refiter:
133 | # Exclude all frames that are from this module.
134 | if isinstance(ref, FrameType): # pragma: nocover on Python 3.11
135 | if ref.f_code.co_filename == self.filename:
136 | continue
137 |
138 | if id(ref) in self._ignore:
139 | continue
140 | elif id(ref) in self.seen: # pragma: nocover
141 | yield depth, id(ref), "!" + get_repr(ref)
142 | continue
143 | else:
144 | self.seen[id(ref)] = None
145 | yield depth, id(ref), get_repr(ref)
146 |
147 | for parent in self._gen(ref, depth + 1):
148 | yield parent
149 |
150 |
151 | class CircularReferents(Tree):
152 |
153 | def walk(self, maxresults=100, maxdepth=None):
154 | """Walk the object tree, showing circular referents."""
155 | self.stops = 0
156 | self.seen = {}
157 | self.ignore(self, self.__dict__, self.seen, self._ignore)
158 |
159 | # Ignore the calling frame, its builtins, globals and locals
160 | self.ignore_caller()
161 |
162 | self.maxdepth = maxdepth
163 | count = 0
164 | for result in self._gen(self.obj):
165 | yield result
166 | count += 1
167 | if maxresults and count >= maxresults:
168 | yield 0, 0, "==== Max results reached ===="
169 | return
170 |
171 | def _gen(self, obj, depth=0, trail=None):
172 | if self.maxdepth and depth >= self.maxdepth:
173 | self.stops += 1
174 | return
175 |
176 | if trail is None:
177 | trail = []
178 |
179 | for ref in gc.get_referents(obj):
180 | if id(ref) in self._ignore:
181 | continue
182 | elif id(ref) in self.seen:
183 | continue
184 | else:
185 | self.seen[id(ref)] = None
186 |
187 | refrepr = get_repr(ref)
188 | if id(ref) == id(self.obj):
189 | yield trail + [refrepr]
190 |
191 | for child in self._gen(ref, depth + 1, trail + [refrepr]):
192 | yield child
193 |
194 | def print_tree(self, maxresults=100, maxdepth=None):
195 | """Walk the object tree, pretty-printing each branch."""
196 | self.ignore_caller()
197 | for trail in self.walk(maxresults, maxdepth):
198 | print(trail)
199 | if self.stops:
200 | print("%s paths stopped because max depth reached" % self.stops)
201 |
202 |
203 | def count_objects():
204 | d = {}
205 | for obj in gc.get_objects():
206 | objtype = type(obj)
207 | d[objtype] = d.get(objtype, 0) + 1
208 | d = [(v, k) for k, v in d.items()]
209 | d.sort(key=itemgetter(0))
210 | return d
211 |
--------------------------------------------------------------------------------
/dozer/tests/test_profile.py:
--------------------------------------------------------------------------------
1 | import builtins
2 | import os
3 | import pickle
4 | import shutil
5 | import sys
6 | import tempfile
7 | import textwrap
8 | import unittest
9 | from collections import namedtuple
10 | from io import StringIO
11 | from unittest.mock import patch
12 |
13 | import webtest
14 |
15 | from dozer.profile import (
16 | Profiler,
17 | color,
18 | graphlabel,
19 | label,
20 | setup_time,
21 | write_dot_graph,
22 | )
23 |
24 |
25 | skip_on_windows = unittest.skipIf(sys.platform == 'win32',
26 | 'Windows has a different permissions model')
27 |
28 |
29 | class TestGlobals(unittest.TestCase):
30 |
31 | def make_code_object(self):
32 | d = {}
33 | exec(compile(textwrap.dedent('''\
34 | # skip a line to get a more interesting line number
35 | def somefunc():
36 | pass
37 | '''), 'sourcefile.py', 'single'), d)
38 | return d['somefunc'].__code__
39 |
40 | def test_label(self):
41 | self.assertEqual(label('somefunc'), 'somefunc')
42 |
43 | def test_label_with_code_object(self):
44 | code = self.make_code_object()
45 | self.assertEqual(label(code), 'somefunc sourcefile.py:2')
46 |
47 | def test_graphlabel(self):
48 | # I don't know if this is a plausible example of things that can be
49 | # passed in, I just know the existing code gets rid of double quotes
50 | self.assertEqual(graphlabel('somefunc "dir with spaces/file.py":42'),
51 | "somefunc 'dir with spaces/file.py':42")
52 |
53 | def test_setup_time(self):
54 | self.assertEqual(setup_time(0.004), '4.00')
55 | self.assertEqual(setup_time(0.00025), '0.25')
56 |
57 | def test_color(self):
58 | self.assertEqual(color(0), '#00002C') # cold: darkish blue
59 | self.assertEqual(color(0.25), '#004C4C') # cool: cyanish
60 | self.assertEqual(color(0.5), '#007900') # medium: green
61 | self.assertEqual(color(0.75), '#B4B400') # warm: very dark yellow
62 | self.assertEqual(color(1), '#FF0000') # hot: red
63 |
64 | def test_write_dot_graph_very_very_fast_function(self):
65 | code = self.make_code_object()
66 | profile_entry = namedtuple('profile_entry', 'code totaltime calls')
67 | with patch.object(builtins, 'open', lambda *a: StringIO()):
68 | data = [profile_entry(code=code, totaltime=1, calls=[])]
69 | tree = {'somefunc sourcefile.py:2': dict(cost=0)}
70 | write_dot_graph(data, tree, 'filename.gv')
71 |
72 |
73 | class AppIter(list):
74 | def close(self):
75 | pass
76 |
77 |
78 | def hello_world(environ, start_response):
79 | body = b'hello, world!'
80 | headers = [('Content-Type', 'text/html; charset=utf8'),
81 | ('Content-Length', str(len(body)))]
82 | start_response('200 Ok', headers)
83 | return AppIter([body])
84 |
85 |
86 | class TestEntireStack(unittest.TestCase):
87 |
88 | def setUp(self):
89 | self.tmpdir = tempfile.mkdtemp('dozer-tests-')
90 |
91 | def tearDown(self):
92 | os.chmod(self.tmpdir, 0o700)
93 | shutil.rmtree(self.tmpdir)
94 |
95 | def make_wsgi_app(self):
96 | profiler = Profiler(hello_world, profile_path=self.tmpdir)
97 | return profiler
98 |
99 | def make_test_app(self):
100 | return webtest.TestApp(self.make_wsgi_app())
101 |
102 | def list_profiles(self, suffix='.pkl'):
103 | return [fn[:-len(suffix)] for fn in os.listdir(self.tmpdir)
104 | if fn.endswith(suffix)]
105 |
106 | def record_profile(self, app):
107 | before = set(self.list_profiles())
108 | app.get('/')
109 | after = set(self.list_profiles())
110 | new = after - before
111 | self.assertEqual(len(new), 1)
112 | return next(iter(new))
113 |
114 | def save_fake_profile(self, prof_id, data):
115 | with open(os.path.join(self.tmpdir, '%s.pkl' % prof_id), 'wb') as f:
116 | f.write(data)
117 |
118 | def test_application_pass_through(self):
119 | app = self.make_test_app()
120 | resp = app.get('/')
121 | self.assertIn('hello, world!', resp)
122 | # a profile is created
123 | self.assertNotEqual(os.listdir(self.tmpdir), [])
124 |
125 | @skip_on_windows
126 | def test_cannot_save_profile(self):
127 | app = self.make_test_app()
128 | os.chmod(self.tmpdir, 0o500)
129 | self.assertRaises(OSError, self.record_profile, app)
130 |
131 | def test_appiter_close_is_called(self):
132 | app = self.make_test_app()
133 | with patch.object(AppIter, 'close') as close:
134 | app.get('/')
135 | self.assertEqual(close.call_count, 1)
136 |
137 | def test_application_ignore_some_paths(self):
138 | app = self.make_test_app()
139 | resp = app.get('/favicon.ico')
140 | self.assertIn('hello, world!', resp)
141 | self.assertEqual(os.listdir(self.tmpdir), [])
142 |
143 | def test_profiler_index(self):
144 | app = self.make_test_app()
145 | self.record_profile(app) # so the list is not empty
146 | self.record_profile(app) # twice so we have someting to sort
147 | resp = app.get('/_profiler')
148 | self.assertEqual(resp.status_int, 200)
149 | self.assertIn('\
29 | View log events for this request
30 | ${'%d' % (1000*tottime)}ms
31 |
32 |
113 |