def test_rendering_base_url():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed(resources=[y1])
incl = Inclusion(needed)
assert incl.render() == '''\
<link rel="stylesheet" type="text/css" href="/fanstatic/foo/b.css" />
<script type="text/javascript" src="/fanstatic/foo/a.js"></script>
<script type="text/javascript" src="/fanstatic/foo/c.js"></script>'''
needed = init_needed(base_url='http://localhost/static', resources=[y1])
incl = Inclusion(needed)
assert incl.render() == '''\
<link rel="stylesheet" type="text/css" href="http://localhost/static/fanstatic/foo/b.css" />
<script type="text/javascript" src="http://localhost/static/fanstatic/foo/a.js"></script>
<script type="text/javascript" src="http://localhost/static/fanstatic/foo/c.js"></script>'''
# The base_url has been set.
assert needed.has_base_url()
needed.set_base_url('foo')
# The base_url can only be set once.
assert needed._base_url == 'http://localhost/static'
def test_mode_fully_specified():
foo = Library('foo', '')
k_debug = Resource(foo, 'k-debug.js')
k = Resource(foo, 'k.js', debug=k_debug)
x = Resource(foo, 'x.js', minified='x-min.js')
needed = init_needed()
needed.need(k)
incl = Inclusion(needed)
assert incl.resources == [k]
incl = Inclusion(needed, mode='debug')
assert incl.resources == [k_debug]
# If no minified can be found, the 'raw' resource is taken.
incl = Inclusion(needed, mode='minified')
assert incl.resources == [k]
# If only a minified resource is defined, debug returns the raw version.
needed = init_needed()
needed.need(x)
incl = Inclusion(needed, mode='debug')
assert incl.resources == [x]
incl = Inclusion(needed, mode='minified')
assert incl.resources == [x.modes['minified']]
def setUp(self):
fanstatic.init_needed()
self.context = object()
self.request = TestRequest()
self.resource_namespace = getMultiAdapter((self.context, self.request),
ITraversable,
name='resource')
def test_include_needed(self):
init_needed()
obj = self._cut()
obj.add('true', self._js_resource, discriminator_true)
obj.add('false', self._js_resource, discriminator_false)
obj.add('none', self._js_resource)
self.assertEqual(obj.include_needed(None, None, None), ['true', 'none'])
needed = get_needed().resources()
self.assertIn(self._js_resource, needed)
def test_include_needed(self):
init_needed()
obj = self._cut()
obj.add('true', self._js_resource, discriminator_true)
obj.add('false', self._js_resource, discriminator_false)
obj.add('none', self._js_resource)
self.assertEqual(obj.include_needed(None, None, None),
['true', 'none'])
needed = get_needed().resources()
self.assertIn(self._js_resource, needed)
def test_rendered_on_event(self):
from arche.events import ViewInitializedEvent
self.config.registry.settings['arche_ga.key'] = 'a_very_secret_code'
self.config.include('arche_google_analytics')
init_needed()
request = testing.DummyRequest()
view = self._mk_view(None, request)
objectEventNotify(ViewInitializedEvent(view))
needed = get_needed()
self.assertTrue(needed.resources())
self.assertIn('a_very_secret_code', needed.render())
def test_convenience_clear_not_initialized():
# This test is put near the top of this module, or at least before
# the very first time ``init_needed()`` is called.
dummy = get_needed()
with pytest.raises(NotImplementedError):
dummy.clear()
with pytest.raises(NotImplementedError):
clear_needed()
# Initialize a needed resources object.
needed = init_needed()
assert get_needed() == needed
assert thread_local_needed_data.__dict__[NEEDED] == needed
# Clear it.
del_needed()
# It is gone, really.
with pytest.raises(KeyError):
thread_local_needed_data.__dict__[NEEDED]
# Clearing it again is OK.
del_needed()
# get_needed still work, dummy-style.
dummy2 = get_needed()
assert dummy2 != needed
with pytest.raises(NotImplementedError):
dummy.clear()
with pytest.raises(NotImplementedError):
clear_needed()
def test_library_url_base_url():
foo = Library('foo', '')
needed = init_needed(base_url="http://example.com/something")
assert (needed.library_url(foo) ==
'http://example.com/something/fanstatic/foo')
def test_convenience_clear_not_initialized():
# This test is put near the top of this module, or at least before
# the very first time ``init_needed()`` is called.
dummy = get_needed()
with pytest.raises(NotImplementedError):
dummy.clear()
with pytest.raises(NotImplementedError):
clear_needed()
# Initialize a needed resources object.
needed = init_needed()
assert get_needed() == needed
assert thread_local_needed_data.__dict__[NEEDED] == needed
# Clear it.
del_needed()
# It is gone, really.
with pytest.raises(KeyError):
thread_local_needed_data.__dict__[NEEDED]
# Clearing it again is OK.
del_needed()
# get_needed still work, dummy-style.
dummy2 = get_needed()
assert dummy2 != needed
with pytest.raises(NotImplementedError):
dummy.clear()
with pytest.raises(NotImplementedError):
clear_needed()
def test_library_ordering_bug():
jquery_lib = Library('jquery', '')
jqueryui_lib = Library('jqueryui', '')
obviel_lib = Library('obviel', '')
bread_lib = Library('bread', '')
app_lib = Library('app', '')
jquery = Resource(jquery_lib, 'jquery.js')
jqueryui = Resource(jqueryui_lib, 'jqueryui.js', depends=[jquery])
obviel = Resource(obviel_lib, 'obviel.js', depends=[jquery])
obviel_forms = Resource(obviel_lib, 'obviel_forms.js', depends=[obviel])
obviel_datepicker = Resource(obviel_lib,
'obviel_datepicker.js',
depends=[obviel_forms, jqueryui])
vtab = Resource(bread_lib, 'vtab.js', depends=[jqueryui])
tabview = Resource(bread_lib, 'tabview.js', depends=[obviel, vtab])
bread = Resource(bread_lib, 'bread.js', depends=[tabview, obviel_forms])
app = Resource(app_lib, 'app.js', depends=[bread, obviel_datepicker])
needed = init_needed(resources=[app])
resources = sort_resources(needed.resources())
for resource in resources:
print((resource, resource.library.library_nr))
assert resources == [
jquery, jqueryui, obviel, obviel_forms, obviel_datepicker, vtab,
tabview, bread, app
]
def test_library_url_version_hashing(tmpdir):
foo = Library('foo', tmpdir.strpath)
# If the Library defines a version, the version is used.
bar = Library('bar', '', version='1')
needed = init_needed(versioning=True)
url = needed.library_url(foo)
assert re.match('/fanstatic/foo/:version:[0-9T:.-]*$', url)
# The md5 based version URL is available through the
# `versioning_use_md5` parameter:
needed = init_needed(versioning=True, versioning_use_md5=True)
md5_url = needed.library_url(foo)
assert url != md5_url
assert needed.library_url(bar) == '/fanstatic/bar/:version:1'
def test_html_bottom_safe():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
y2 = Resource(foo, 'y2.js', bottom=True)
needed = init_needed(resources=[y1, y2])
injector = TopBottomInjector({})
top, bottom = injector.group(needed)
assert len(top) == 4
assert len(bottom) == 0
injector = TopBottomInjector(dict(bottom=True))
top, bottom = injector.group(needed)
assert len(top) == 3
assert len(bottom) == 1
# The bottom resource is y2.
assert bottom.resources[0] == y2
injector = TopBottomInjector(dict(bottom=True, force_bottom=True))
top, bottom = injector.group(needed)
assert len(top) == 1
assert len(bottom) == 3
top, bottom = injector.group(needed)
assert len(top) == 1
assert top.resources[0] == x2
assert len(bottom) == 3
def test_no_need_to_fill_in_not_required():
lib = Library('lib', '')
slot = Slot(lib, '.js', required=False)
a = Resource(lib, 'a.js', depends=[slot])
needed = init_needed(resources=[a])
# slot wasn't required and not filled in, so filled slot doesn't show up
assert needed.resources() == set([a])
def test_slot_with_default_uses_default_if_nothing_given_in_need():
lib = Library('lib', '')
default_resource_for_slot = Resource(lib, 'b.js')
slot = Slot(lib, '.js', default=default_resource_for_slot)
a = Resource(lib, 'a.js', depends=[slot])
needed = init_needed(resources=[a])
relpaths = [r.relpath for r in sort_resources(needed.resources())]
assert relpaths == ['b.js', 'a.js']
def test_empty_base_url_and_publisher_signature():
''' When the base_url is not set and the publisher_signature is an empty string,
render a URL without them. '''
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
needed = init_needed(publisher_signature='', resources=[x1])
incl = Inclusion(needed)
assert incl.render() == '''\
def before_request(self):
g.fanstatic = _FanstaticContext(
init_needed(
# TODO set base_url for this app if needed
**current_app.config.get("FANSTATIC_OPTIONS", {})
),
self,
)
def test_library_url_script_name_base_url():
foo = Library('foo', '')
needed = init_needed(script_name='/root',
base_url="http://example.com/something")
# base_url is set so script_name should be ignored
assert (needed.library_url(foo) ==
'http://example.com/something/fanstatic/foo')
def test_html_insert_head_with_attributes():
# ticket 72: .need() broken when <head> tag has attributes
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
needed = init_needed(resources=[x1])
injector = TopBottomInjector({})
html = b'<html><head profile="http://example.org">something</head></html>'
assert injector(html, needed) == b'''\
def test_resource():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed()
needed.need(y1)
assert needed.resources() == set([x2, x1, y1])
def test_rendering():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed(resources=[y1])
incl = Inclusion(needed)
assert incl.render() == '''\
def test_inclusion_rollup_and_debug_missing():
foo = Library('foo', '')
h1 = Resource(foo, 'h1.js', debug='h1-debug.js')
h2 = Resource(foo, 'h2.js', debug='h2-debug.js')
gianth = Resource(foo, 'gianth.js', supersedes=[h1, h2])
needed = init_needed(resources=[h1, h2])
incl = Inclusion(needed, rollup=True, mode='debug')
# No mode debug version of the rollup use it instead
assert incl.resources == [gianth]
def test_rendering_base_url_assign():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed(resources=[y1])
needed.set_base_url('http://localhost/static')
incl = Inclusion(needed)
assert incl.render() == '''\
def test_register_form_resources(self):
import colander
import deform
class DummySchema(colander.Schema):
dummy = colander.SchemaNode(colander.String())
dummy_form = deform.Form(DummySchema())
from fanstatic import get_needed
from fanstatic import init_needed
from fanstatic import NeededResources
init_needed() #Otherwise fanstatic won't get a proper needed resrouces object.
context = testing.DummyResource()
request = testing.DummyRequest()
obj = self._cut(context, request)
obj.register_form_resources(dummy_form)
needed_resources = get_needed()
self.assertIsInstance(needed_resources, NeededResources)
filenames = [x.filename for x in needed_resources.resources()]
#Note: Can be any filename registered by VoteIT. Just change it if this test fails :)
self.assertIn('deform.css', filenames)
def test_html_insert():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed(resources=[y1])
injector = TopBottomInjector({})
html = b"<html><head>something more</head></html>"
assert injector(html, needed) == b'''\
def test_minified_mode_relpath_respect_subdir(compilers):
compilers.add_compiler(MockCompiler())
compilers.add_minifier(MockMinifier())
lib = Library('lib', '')
a = Resource(lib, 'foo/bar/a.js', compiler='mock', minifier='mock')
needed = init_needed(resources=[a])
incl = Inclusion(needed, compile=True, mode=MINIFIED)
assert len(incl.resources) == 1
assert incl.resources[0].relpath == 'foo/bar/a.min.js'
assert incl.resources[0] != a
def test_bundle_resources():
foo = Library('foo', '')
x1 = Resource(foo, 'a.css')
x2 = Resource(foo, 'b.css')
x3 = Resource(foo, 'c.css', dont_bundle=True)
bar = Library('bar', '')
y1 = Resource(bar, 'y1.css')
y2 = Resource(bar, 'y2.css')
y3 = Resource(bar, 'subdir/y3.css')
y4 = Resource(bar, 'subdir/y4.css')
init_needed()
bundle = bundle_resources([x1, x2])
assert len(bundle) == 1
assert isinstance(bundle[0], Bundle)
# x3 is not bundle safe.
bundle = bundle_resources([x1, x3])
assert len(bundle) == 2
# We don't create bundles of one element.
assert bundle[0] == x1
assert bundle[1] == x3
# x2 and x1 are not bundled because x3 is in the way.
# (sort_resources in NeededResources fixes the sorting)
bundle = bundle_resources([x1, x3, x2])
assert bundle == [x1, x3, x2]
# The resources are sorted by renderer order, library dependencies
# and resource dependencies.
bundle = bundle_resources(sort_resources([x1, x3, x2]))
assert len(bundle) == 2
assert isinstance(bundle[0], Bundle)
assert bundle[1] == x3
bundle = bundle_resources([x1, x2, y1, y2])
assert len(bundle) == 2
bundle = bundle_resources([y1, y2, y3, y4])
assert len(bundle) == 2
def test_fill_slot_wrong_extension():
lib = Library('lib', '')
slot = Slot(lib, '.js')
a = Resource(lib, 'a.js', depends=[slot])
b = Resource(lib, 'b.css')
needed = init_needed()
needed.need(a, {slot: b})
with pytest.raises(SlotError):
needed.resources()
def test_redundant_resource_reorder():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed()
needed.need(x1)
needed.need(x2)
needed.need(y1)
incl = Inclusion(needed)
assert incl.resources == [x2, x1, y1]
def test_sort_library_by_name():
b_lib = Library('b_lib', '')
a_lib = Library('a_lib', '')
a_a = Resource(a_lib, 'a.js')
a_b = Resource(b_lib, 'a.js')
needed = init_needed()
needed.need(a_b)
needed.need(a_a)
assert sort_resources(needed.resources()) == [a_a, a_b]
def test_resource_subclass_render():
foo = Library('foo', '')
class MyResource(Resource):
def render(self, library_url):
return '<myresource reference="%s/%s"/>' % (library_url,
self.relpath)
a = MyResource(foo, 'printstylesheet.css')
needed = init_needed(resources=[a])
incl = Inclusion(needed)
assert incl.render() == """\
def test_library_url_hashing_recompute(tmpdir):
foo = Library('foo', tmpdir.strpath)
needed = init_needed(versioning=True, recompute_hashes=True)
url = needed.library_url(foo)
# now create a file
resource = tmpdir.join('test.js')
time.sleep(0.5)
# Sleep extra long on filesystems that report in seconds
# instead of milliseconds.
if os.path.getmtime(os.curdir).is_integer():
time.sleep(1)
resource.write('/* test */')
# For a new request, the url is recomputed.
new_needed = init_needed(versioning=True, recompute_hashes=True)
# the hash is recalculated now, so it changes
assert new_needed.library_url(foo) != url
def test_html_top_bottom_force_bottom():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed(resources=[y1])
injector = TopBottomInjector(dict(bottom=True, force_bottom=True))
top, bottom = injector.group(needed)
assert top.resources == [x2]
assert bottom.resources == [x1, y1]
def test_default_can_be_overridden():
lib = Library('lib', '')
default_resource_for_slot = Resource(lib, 'b.js')
slot = Slot(lib, '.js', default=default_resource_for_slot)
a = Resource(lib, 'a.js', depends=[slot])
custom_resource_for_slot = Resource(lib, 'c.js')
needed = init_needed()
needed.need(a, {slot: custom_resource_for_slot})
relpaths = [r.relpath for r in sort_resources(needed.resources())]
assert relpaths == ['c.js', 'a.js']
def test_top_bottom_insert():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
html = b"<html><head>start of head</head><body>rest of body</body></html>"
needed = init_needed(resources=[y1])
injector = TopBottomInjector(dict(bottom=True, force_bottom=True))
assert injector(html, needed) == b'''\
def test_redundant_more_complicated_depends_on_all():
foo = Library('foo', '')
a1 = Resource(foo, 'a1.js')
a2 = Resource(foo, 'a2.js', depends=[a1])
a3 = Resource(foo, 'a3.js', depends=[a2])
a4 = Resource(foo, 'a4.js', depends=[a1])
a5 = Resource(foo, 'a5.js', depends=[a4, a3])
needed = init_needed()
needed.need(a5)
incl = Inclusion(needed)
assert incl.resources == [a1, a2, a4, a3, a5]
def test_convenience_need():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
needed = init_needed()
assert get_needed() == needed
assert get_needed().resources() == []
y1.need()
assert get_needed().resources() == [x2, x1, y1]
def test_convenience_group_resource_need():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js')
group = Group([x1, x2, y1])
needed = init_needed()
assert get_needed() == needed
assert get_needed().resources() == []
group.need()
assert get_needed().resources() == [x2, x1, y1]
def test_resource_need_should_pass_slots_to_needed():
import fanstatic
lib = Library("lib", "")
c = Resource(lib, "c.js")
slot = Slot(lib, ".js", depends=[c])
a = Resource(lib, "a.js", depends=[slot])
b = Resource(lib, "b.js", depends=[c])
needed = fanstatic.init_needed()
try:
a.need({slot: c})
finally:
fanstatic.del_needed()
assert slot in needed._slots
def __call__(self, request):
# publisher
if len(request.path_info.split(self.trigger)) > 1:
path_info = request.path_info
ignored = request.path_info_pop()
while ignored != self.publisher_signature:
ignored = request.path_info_pop()
response = request.get_response(self.publisher)
# forward to handler if the resource could not be found
if response.status_int == 404:
request.path_info = path_info
return self.handler(request)
return response
# injector
needed = fanstatic.init_needed(**self.config)
if self.use_application_uri and not needed.has_base_url():
base_url = wsgiref.util.application_uri(request.environ)
# remove trailing slash for fanstatic
needed.set_base_url(base_url.rstrip('/'))
request.environ[fanstatic.NEEDED] = needed
response = self.handler(request)
if not (response.content_type and
response.content_type.lower() in ['text/html',
'text/xml']):
fanstatic.del_needed()
return response
if needed.has_resources():
# Using response.body may cause a UnicodeDecodeError if some of
# the libraries contain unicode strings. So it's best to pass
# unicode_body directly, so the regexps won't fail.
if self.injector is not None:
result = self.injector(response.unicode_body,
needed, request, response)
else:
result = needed.render_topbottom_into_html(
response.unicode_body)
response.body = ''
response.write(result)
fanstatic.del_needed()
return response
def test_convenience_clear():
foo = Library('foo', '')
x1 = Resource(foo, 'a.js')
x2 = Resource(foo, 'b.css')
y1 = Resource(foo, 'c.js', depends=[x1, x2])
z1 = Resource(foo, 'd.js')
z2 = Resource(foo, 'e.js', depends=[z1, x1])
needed = init_needed(resources=[y1])
assert sort_resources(needed.resources()) == [x2, x1, y1]
# For some reason,for example an error page needs to be rendered,
# the currently needed resources need to be cleared.
clear_needed()
assert len(needed.resources()) == 0
z2.need()
assert sort_resources(needed.resources()) == [x1, z1, z2]
def __call__(self, environ, start_response):
request = webob.Request(environ)
# We only continue if the request method is appropriate.
if not request.method in ['GET', 'POST']:
return self.app(environ, start_response)
# Initialize a needed resources object.
# XXX this will set the needed on the thread local data, even
# if the wrapped framework only gets the needed from the WSGI
# environ.
needed = fanstatic.init_needed(
script_name=request.environ.get('SCRIPT_NAME'), **self.config)
# Make sure the needed resource object is put in the WSGI
# environment as well, for frameworks that choose to use it
# from there.
request.environ[fanstatic.NEEDED] = needed
# Get the response from the wrapped application:
response = request.get_response(self.app)
# We only continue if the content-type is appropriate.
if not (response.content_type and
response.content_type.lower() in CONTENT_TYPES):
# Clean up after our behinds.
fanstatic.del_needed()
return response(environ, start_response)
# The wrapped application may have `needed` resources.
if needed.has_resources():
# Can't use response.text because there might not be any
# charset. body is not unicode.
result = needed.render_topbottom_into_html(response.body)
# Reset the body...
response.body = b''
# Write will propely unfolder the previous application and
# call close. Setting response.text or response.body won't do it.
response.write(result)
# Clean up after our behinds.
fanstatic.del_needed()
return response(environ, start_response)
def decorated(request):
# injector
needed = fanstatic.init_needed(**self.config)
request.environ[fanstatic.NEEDED] = needed
self.need_fanstatic()
response = view(request)
if not (response.content_type and
response.content_type.lower() in ['text/html',
'text/xml']):
fanstatic.del_needed()
return response
if needed.has_resources():
result = needed.render_topbottom_into_html(response.body)
response.body = ''
response.write(result)
fanstatic.del_needed()
return response
def __call__(self, request):
# publisher
if len(request.path_info.split(self.trigger)) > 1:
path_info = request.path_info
ignored = request.path_info_pop()
while ignored != self.publisher_signature:
ignored = request.path_info_pop()
response = request.get_response(self.publisher)
# forward to handler if the resource could not be found
if response.status_int == 404:
request.path_info = path_info
return self.handler(request)
return response
# injector
needed = fanstatic.init_needed(**self.config)
if self.use_application_uri and not needed.has_base_url():
base_url = wsgiref.util.application_uri(request.environ)
# remove trailing slash for fanstatic
needed.set_base_url(base_url.rstrip("/"))
request.environ[fanstatic.NEEDED] = needed
response = self.handler(request)
if not (response.content_type and response.content_type.lower() in ["text/html", "text/xml"]):
fanstatic.del_needed()
return response
if needed.has_resources():
if self.injector is not None:
result = self.injector(response.body, needed, request, response)
else:
result = needed.render_topbottom_into_html(response.body)
try:
response.text = ""
except TypeError:
response.body = ""
response.write(result)
fanstatic.del_needed()
return response
def __call__(self, request):
needed = fanstatic.init_needed(**self.config)
if self.use_application_uri and not needed.has_base_url():
base_url = wsgiref.util.application_uri(request.environ)
# remove trailing slash for fanstatic
needed.set_base_url(base_url.rstrip('/'))
request.environ[fanstatic.NEEDED] = needed
try:
response = self.handler(request)
if response.content_type \
and response.content_type.lower() in CONTENT_TYPES \
and needed.has_resources():
result = self.injector(response.body, needed, request, response)
response.body = ''
response.write(result)
return response
finally:
fanstatic.del_needed()
def __call__(self, request):
# We only continue if the request method is appropriate.
if not request.method in ['GET', 'POST']:
return request.get_response(self.app)
# Initialize a needed resources object.
# XXX this will set the needed on the thread local data, even
# if the wrapped framework only gets the needed from the WSGI
# environ.
needed = fanstatic.init_needed(**self.config)
# Make sure the needed resource object is put in the WSGI
# environment as well, for frameworks that choose to use it
# from there.
request.environ[fanstatic.NEEDED] = needed
# Get the response from the wrapped application:
response = request.get_response(self.app)
# We only continue if the content-type is appropriate.
if not (response.content_type and
response.content_type.lower() in ['text/html', 'text/xml']):
# Clean up after our behinds.
fanstatic.del_needed()
return response
# The wrapped application may have `needed` resources.
if needed.has_resources():
result = needed.render_topbottom_into_html(response.body)
# Reset the body...
response.body = ''
# And write the result. The `write` method handles unicode results.
response.write(result)
# Clean up after our behinds.
fanstatic.del_needed()
return response
def transformIterable(self, result, encoding):
if not isinstance(result, XMLSerializer):
getHeader = self.request.response.getHeader
content_type = getHeader('Content-Type')
if content_type is None or \
not content_type.startswith('text/html'):
return None
contentEncoding = getHeader('Content-Encoding')
if contentEncoding and \
contentEncoding in ('zip', 'deflate', 'compress',):
return None
try:
result = getHTMLSerializer(result, encoding=encoding,
pretty_print=self.pretty_print)
except (TypeError, etree.ParseError):
return None
resources = fanstatic.init_needed(
base_url=self.request.getURL(),
publisher_signature='/++fanstatic++/',
)
from plone.fanstatic import groups
for group in groups:
group.need()
resources = etree.HTML(resources.render()).find('head').getchildren()
head = resources and result.tree.getroot().find('head') or None
# Ajax are without head...
if head:
for item in resources:
head.append(item)
return result
def setUp(self):
fanstatic.init_needed()
self.context = object()
self.request = TestRequest()
self.resource_namespace = getMultiAdapter(
(self.context, self.request), ITraversable, name='resource')
def setUp(self):
self.config = testing.setUp()
init_needed()
def initalize_fanstatic(context, event):
base_url = IBaseUrl(event.request).url()
base_url = base_url[:-1] # just remove the slash (IBaseUrl always return a slash at the end)
needed = fanstatic.init_needed(base_url=base_url, debug=False)
context.resources.need()
def _clearFLib(*args):
from deform_autoneed import deform_autoneed_lib
#To clear any old registered resources - needs to be done on test start too for some reason.
deform_autoneed_lib.known_resources = {}
init_needed()
def __init__(self, manager, **config): # call this first, to pop some items from the config self._injector = _make_injector(config) self._needed = init_needed(**config) self._manager = manager self._rendered = False
def test_start_raiting_included(self):
from voteit.core.fanstaticlib import _star_rating_css
init_needed()
obj = self._cut()
needed = get_needed().resources()
self.assertIn(_star_rating_css, needed)
