class TestCLI(object):
def setup(self):
self.assets_env = Environment('', '')
self.cmd_env = CommandLineEnvironment(self.assets_env, logging)
def test_rebuild_container_bundles(self):
"""Test the rebuild command can deal with container bundles.
"""
a = MockBundle(output='a')
b1 = MockBundle(output='b1')
b2 = MockBundle(output='b2')
b = MockBundle(b1, b2)
self.assets_env.add(a, b)
self.cmd_env.rebuild()
assert a.build_called
assert not b.build_called
assert b1.build_called
assert b2.build_called
class TestCLI(object):
def setup(self):
self.assets_env = Environment("", "")
self.cmd_env = CommandLineEnvironment(self.assets_env, logging)
def test_rebuild_container_bundles(self):
"""Test the rebuild command can deal with container bundles.
"""
a = MockBundle(output="a")
b1 = MockBundle(output="b1")
b2 = MockBundle(output="b2")
b = MockBundle(b1, b2)
self.assets_env.add(a, b)
self.cmd_env.rebuild()
assert a.build_called
assert not b.build_called
assert b1.build_called
assert b2.build_called
def compressFile(f, webFilters):
filePath = os.path.join(webFolder, f)
baseName = os.path.basename(filePath)
prefix = f[0:len(f) - len(baseName)]
fn = os.path.splitext(baseName)
newFileName = fn[0] + '.%(version)s' + fn[1]
env = Environment("")
env.auto_build = False
env.url_expire = True
tmpFile = os.path.join(tempFolder, newFileName)
env.url_mapping = {tempFolder: ''}
bundle = Bundle(filePath, filters=webFilters, output=tmpFile)
env.add(bundle)
bundle.build()
vfn = bundle.urls()[0][1:]
if (vfn.index("?") > 0):
vfn = vfn[0:vfn.index("?")]
#print(prefix, vfn)
zf.write(os.path.join(tempFolder, vfn), prefix + vfn)
return prefix + vfn
class TestEnvApi(object):
"""General Environment functionality."""
def setup(self):
self.m = Environment(None, None)
def test_register_single_bundle(self):
"""Test registering a single ``Bundle`` object.
"""
b = Bundle()
self.m.register('foo', b)
assert self.m['foo'] == b
def test_register_dict(self):
"""Register a bunch of bundles at once."""
a = Bundle()
b = Bundle()
self.m.register({'foo': a, 'bar': b})
assert self.m['foo'] == a
assert self.m['bar'] == b
def test_register_new_bundle(self):
"""Test self.m.registering a new bundle on the fly.
"""
b = Bundle()
self.m.register('foo', b, 's2', 's3')
assert b in self.m['foo'].contents
# Special case of using only a single, non-bundle source argument.
self.m.register('footon', 's1')
assert 's1' in self.m['footon'].contents
# Special case of specifying only a single bundle as a source, but
# additional options - this also creates a wrapping bundle.
self.m.register('foofighters', b, output="bar")
assert b in self.m['foofighters'].contents
def test_register_invalid_call(self):
"""Test calling self.m.register with an invalid syntax.
"""
assert_raises(TypeError, self.m.register)
assert_raises(TypeError, self.m.register, 'one-argument-only')
def test_register_duplicate(self):
"""Test name clashes.
"""
b1 = Bundle()
b2 = Bundle()
self.m.register('foo', b1)
# Multiple calls with the same name are ignored if the given bundle
# is the same as originally passed.
self.m.register('foo', b1)
assert len(self.m) == 1
# Otherwise, an error is raised.
assert_raises(RegisterError, self.m.register, 'foo', b2)
assert_raises(RegisterError, self.m.register, 'foo', 's1', 's2', 's3')
def test_register_anon_bundle(self):
"""Self registering an anonymous bundle.
"""
b = Bundle()
self.m.add(b)
assert len(self.m) == 1
assert list(self.m) == [b]
def test_contains(self):
"""Test __contains__.
"""
b = Bundle()
self.m.register('foo', b)
assert 'foo' in self.m
assert not 'bar' in self.m
def test_url_and_directory(self):
"""The url and directory options are a bit special, because they
are so essential.
"""
# An environment can be constructed without given url or directory.
env = Environment()
# But then accessing them will fail, and with it most operations.
assert_raises(EnvironmentError, getattr, env, 'url')
assert_raises(EnvironmentError, getattr, env, 'directory')
# Test constructing the environment with values for url and directory
env = Environment('foo', 'bar')
assert env.url == 'bar'
assert env.config['directory'] == 'foo'
assert env.directory == os.path.join(os.getcwd(), 'foo')
def test_append_load_path(self):
env = Environment()
assert env.load_path == []
env.append_path('foo', '/foo')
assert env.load_path == ['foo']
assert env.url_mapping == {'foo': '/foo'}
# Works without path
env.append_path('bar')
assert env.load_path == ['foo', 'bar']
assert env.url_mapping == {'foo': '/foo'}
class TestEnvApi(object):
"""General Environment functionality."""
def setup(self):
self.m = Environment(None, None)
def test_single_bundle(self):
"""Test self.m.registering a single ``Bundle`` object.
"""
b = Bundle()
self.m.register('foo', b)
assert self.m['foo'] == b
def test_new_bundle(self):
"""Test self.m.registering a new bundle on the fly.
"""
b = Bundle()
self.m.register('foo', b, 's2', 's3')
assert b in self.m['foo'].contents
# Special case of using only a single, non-bundle source argument.
self.m.register('footon', 's1')
assert 's1' in self.m['footon'].contents
# Special case of specifying only a single bundle as a source, but
# additional options - this also creates a wrapping bundle.
self.m.register('foofighters', b, output="bar")
assert b in self.m['foofighters'].contents
def test_invalid_call(self):
"""Test calling self.m.register with an invalid syntax.
"""
assert_raises(TypeError, self.m.register)
assert_raises(TypeError, self.m.register, 'one-argument-only')
def test_duplicate(self):
"""Test name clashes.
"""
b1 = Bundle()
b2 = Bundle()
self.m.register('foo', b1)
# Multiple calls with the same name are ignored if the given bundle
# is the same as originally passed.
self.m.register('foo', b1)
assert len(self.m) == 1
# Otherwise, an error is raised.
assert_raises(RegisterError, self.m.register, 'foo', b2)
assert_raises(RegisterError, self.m.register, 'foo', 's1', 's2', 's3')
def test_anon_bundle(self):
"""Self registering an anonymous bundle.
"""
b = Bundle()
self.m.add(b)
assert len(self.m) == 1
assert list(self.m) == [b]
def test_contains(self):
"""Test __contains__.
"""
b = Bundle()
self.m.register('foo', b)
assert 'foo' in self.m
assert not 'bar' in self.m
class TestEnvApi:
"""General Environment functionality."""
def setup(self):
self.m = Environment(None, None)
def test_single_bundle(self):
"""Test self.m.registering a single ``Bundle`` object.
"""
b = Bundle()
self.m.register('foo', b)
assert self.m['foo'] == b
def test_new_bundle(self):
"""Test self.m.registering a new bundle on the fly.
"""
b = Bundle()
self.m.register('foo', b, 's2', 's3')
assert b in self.m['foo'].contents
# Special case of using only a single, non-bundle source argument.
self.m.register('footon', 's1')
assert 's1' in self.m['footon'].contents
# Special case of specifying only a single bundle as a source, but
# additional options - this also creates a wrapping bundle.
self.m.register('foofighters', b, output="bar")
assert b in self.m['foofighters'].contents
def test_invalid_call(self):
"""Test calling self.m.register with an invalid syntax.
"""
assert_raises(TypeError, self.m.register)
assert_raises(TypeError, self.m.register, 'one-argument-only')
def test_duplicate(self):
"""Test name clashes.
"""
b1 = Bundle()
b2 = Bundle()
self.m.register('foo', b1)
# Multiple calls with the same name are ignored if the given bundle
# is the same as originally passed.
self.m.register('foo', b1)
assert len(self.m) == 1
# Otherwise, an error is raised.
assert_raises(RegisterError, self.m.register, 'foo', b2)
assert_raises(RegisterError, self.m.register, 'foo', 's1', 's2', 's3')
def test_anon_bundle(self):
"""Self registering an anonymous bundle.
"""
b = Bundle()
self.m.add(b)
assert len(self.m) == 1
assert list(self.m) == [b]
def test_contains(self):
"""Test __contains__.
"""
b = Bundle()
self.m.register('foo', b)
assert 'foo' in self.m
assert not 'bar' in self.m
class TestEnvApi(object):
"""General Environment functionality."""
def setup(self):
self.m = Environment(None, None)
def test_single_bundle(self):
"""Test registering a single ``Bundle`` object.
"""
b = Bundle()
self.m.register('foo', b)
assert self.m['foo'] == b
def test_new_bundle(self):
"""Test self.m.registering a new bundle on the fly.
"""
b = Bundle()
self.m.register('foo', b, 's2', 's3')
assert b in self.m['foo'].contents
# Special case of using only a single, non-bundle source argument.
self.m.register('footon', 's1')
assert 's1' in self.m['footon'].contents
# Special case of specifying only a single bundle as a source, but
# additional options - this also creates a wrapping bundle.
self.m.register('foofighters', b, output="bar")
assert b in self.m['foofighters'].contents
def test_invalid_call(self):
"""Test calling self.m.register with an invalid syntax.
"""
assert_raises(TypeError, self.m.register)
assert_raises(TypeError, self.m.register, 'one-argument-only')
def test_duplicate(self):
"""Test name clashes.
"""
b1 = Bundle()
b2 = Bundle()
self.m.register('foo', b1)
# Multiple calls with the same name are ignored if the given bundle
# is the same as originally passed.
self.m.register('foo', b1)
assert len(self.m) == 1
# Otherwise, an error is raised.
assert_raises(RegisterError, self.m.register, 'foo', b2)
assert_raises(RegisterError, self.m.register, 'foo', 's1', 's2', 's3')
def test_anon_bundle(self):
"""Self registering an anonymous bundle.
"""
b = Bundle()
self.m.add(b)
assert len(self.m) == 1
assert list(self.m) == [b]
def test_contains(self):
"""Test __contains__.
"""
b = Bundle()
self.m.register('foo', b)
assert 'foo' in self.m
assert not 'bar' in self.m
def test_url_and_directory(self):
"""The url and directory options are a bit special, because they
are so essential.
"""
# An environment can be constructed without given url or directory.
env = Environment()
# But then accessing them will fail, and with it most operations.
assert_raises(EnvironmentError, getattr, env, 'url')
assert_raises(EnvironmentError, getattr, env, 'directory')
# Test constructing the environment with values for url and directory
env = Environment('foo', 'bar')
assert env.directory == 'foo'
assert env.url == 'bar'
#!/usr/bin/env python
from os import path
from webassets import Bundle, Environment
env = Environment(path.join(path.dirname(__file__), 'static'), '/stylesheets')
# App Engine doesn't support automatic rebuilding.
env.auto_build = False
# This file needs to be shipped with your code.
env.manifest = 'file'
bundle = Bundle('in.css', filters="cssmin", output="out.css")
env.add(bundle)
if __name__== "__main__":
# If this file is called directly, do a manual build.
bundle.build()
#!/usr/bin/env python
from os import path
from webassets import Bundle, Environment
env = Environment(path.join(path.dirname(__file__), 'static'), '/stylesheets')
# App Engine doesn't support automatic rebuilding.
env.updater = False
# URL expiry not currently supported on App Engine
env.expire = False
bundle = Bundle('in.css', filters="cssmin", output="out.css")
env.add(bundle)
if __name__== "__main__":
# If this file is called directly, do a manual build.
bundle.build()
class TestEnvApi(object):
"""General Environment functionality."""
def setup(self):
self.m = Environment(None, None)
def test_register_single_bundle(self):
"""Test registering a single ``Bundle`` object.
"""
b = Bundle()
self.m.register("foo", b)
assert self.m["foo"] == b
def test_register_dict(self):
"""Register a bunch of bundles at once."""
a = Bundle()
b = Bundle()
self.m.register({"foo": a, "bar": b})
assert self.m["foo"] == a
assert self.m["bar"] == b
def test_register_new_bundle(self):
"""Test self.m.registering a new bundle on the fly.
"""
b = Bundle()
self.m.register("foo", b, "s2", "s3")
assert b in self.m["foo"].contents
# Special case of using only a single, non-bundle source argument.
self.m.register("footon", "s1")
assert "s1" in self.m["footon"].contents
# Special case of specifying only a single bundle as a source, but
# additional options - this also creates a wrapping bundle.
self.m.register("foofighters", b, output="bar")
assert b in self.m["foofighters"].contents
def test_register_invalid_call(self):
"""Test calling self.m.register with an invalid syntax.
"""
assert_raises(TypeError, self.m.register)
assert_raises(TypeError, self.m.register, "one-argument-only")
def test_register_duplicate(self):
"""Test name clashes.
"""
b1 = Bundle()
b2 = Bundle()
self.m.register("foo", b1)
# Multiple calls with the same name are ignored if the given bundle
# is the same as originally passed.
self.m.register("foo", b1)
assert len(self.m) == 1
# Otherwise, an error is raised.
assert_raises(RegisterError, self.m.register, "foo", b2)
assert_raises(RegisterError, self.m.register, "foo", "s1", "s2", "s3")
def test_register_anon_bundle(self):
"""Self registering an anonymous bundle.
"""
b = Bundle()
self.m.add(b)
assert len(self.m) == 1
assert list(self.m) == [b]
def test_contains(self):
"""Test __contains__.
"""
b = Bundle()
self.m.register("foo", b)
assert "foo" in self.m
assert not "bar" in self.m
def test_bool_evaluation(self):
"""Test that environment evaluates to True in a boolean context.
"""
env = Environment()
assert env
def test_url_and_directory(self):
"""The url and directory options are a bit special, because they
are so essential.
"""
# An environment can be constructed without given url or directory.
env = Environment()
# But then accessing them will fail, and with it most operations.
assert_raises(EnvironmentError, getattr, env, "url")
assert_raises(EnvironmentError, getattr, env, "directory")
# Test constructing the environment with values for url and directory
env = Environment("foo", "bar")
assert env.url == "bar"
assert env.config["directory"] == "foo"
assert env.directory == os.path.join(os.getcwd(), "foo")
def test_append_load_path(self):
env = Environment()
assert env.load_path == []
env.append_path("foo", "/foo")
assert env.load_path == ["foo"]
assert env.url_mapping == {"foo": "/foo"}
# Works without path
env.append_path("bar")
assert env.load_path == ["foo", "bar"]
assert env.url_mapping == {"foo": "/foo"}
class TestEnvApi(object):
"""General Environment functionality."""
def setup(self):
self.m = Environment(None, None)
def test_register_single_bundle(self):
"""Test registering a single ``Bundle`` object.
"""
b = Bundle()
self.m.register('foo', b)
assert self.m['foo'] == b
def test_register_dict(self):
"""Register a bunch of bundles at once."""
a = Bundle()
b = Bundle()
self.m.register({'foo': a, 'bar': b})
assert self.m['foo'] == a
assert self.m['bar'] == b
def test_register_new_bundle(self):
"""Test self.m.registering a new bundle on the fly.
"""
b = Bundle()
self.m.register('foo', b, 's2', 's3')
assert b in self.m['foo'].contents
# Special case of using only a single, non-bundle source argument.
self.m.register('footon', 's1')
assert 's1' in self.m['footon'].contents
# Special case of specifying only a single bundle as a source, but
# additional options - this also creates a wrapping bundle.
self.m.register('foofighters', b, output="bar")
assert b in self.m['foofighters'].contents
def test_register_composed_bundle(self):
"""Test registering a bundle with `merge=False`
"""
env = Environment('tests')
env.register('base1',
'helpers.py',
'test_ext/__init__.py',
merge=False,
output='build/%(name)s.%(version)s.css')
assert 'base1' not in env
assert 'base1/helpers.py' in env
assert 'base1/__init__.py' in env
env.register('',
'helpers.py',
'test_ext/__init__.py',
merge=False,
output='build/%(name)s.css')
assert 'helpers.py' in env
assert '__init__.py' in env
assert env['helpers.py'].output == 'build/helpers.css'
assert env['__init__.py'].output == 'build/__init__.css'
env.register('base2',
'helper*.*',
merge=False,
output='build/%(name)s.%(ext)s')
assert 'base2/helpers.py' in env
assert env['base2/helpers.py'].output == 'build/helpers.py'
env.register('base3',
'test_ext/__init__.py',
merge=False,
output='build/%(path)s.css')
assert env['base3/__init__.py'].output == 'build/test_ext/__init__.css'
def test_register_composed_invalid(self):
"""Test registering a bundle with `merge=False`
and invalid options.
"""
env = Environment('tests')
# No `output`
pytest.raises(RegisterError,
env.register,
'base1',
'helpers.py',
merge=False)
# Nested bundle
b = Bundle()
pytest.raises(RegisterError,
env.register,
'base2',
'helpers.py',
b,
merge=False,
output='a')
def test_register_invalid_call(self):
"""Test calling self.m.register with an invalid syntax.
"""
pytest.raises(TypeError, self.m.register)
pytest.raises(TypeError, self.m.register, 'one-argument-only')
def test_register_duplicate(self):
"""Test name clashes.
"""
b1 = Bundle()
b2 = Bundle()
self.m.register('foo', b1)
# Multiple calls with the same name are ignored if the given bundle
# is the same as originally passed.
self.m.register('foo', b1)
assert len(self.m) == 1
# Otherwise, an error is raised.
pytest.raises(RegisterError, self.m.register, 'foo', b2)
pytest.raises(RegisterError, self.m.register, 'foo', 's1', 's2', 's3')
def test_register_anon_bundle(self):
"""Self registering an anonymous bundle.
"""
b = Bundle()
self.m.add(b)
assert len(self.m) == 1
assert list(self.m) == [b]
def test_contains(self):
"""Test __contains__.
"""
b = Bundle()
self.m.register('foo', b)
assert 'foo' in self.m
assert 'bar' not in self.m
def test_bool_evaluation(self):
"""Test that environment evaluates to True in a boolean context.
"""
env = Environment()
assert env
def test_url_and_directory(self):
"""The url and directory options are a bit special, because they
are so essential.
"""
# An environment can be constructed without given url or directory.
env = Environment()
# But then accessing them will fail, and with it most operations.
pytest.raises(EnvironmentError, getattr, env, 'url')
pytest.raises(EnvironmentError, getattr, env, 'directory')
# Test constructing the environment with values for url and directory
env = Environment('foo', 'bar')
assert env.url == 'bar'
assert env.config['directory'] == 'foo'
assert env.directory == os.path.join(os.getcwd(), 'foo')
def test_append_load_path(self):
env = Environment()
assert env.load_path == []
env.append_path('foo', '/foo')
assert env.load_path == ['foo']
assert env.url_mapping == {'foo': '/foo'}
# Works without path
env.append_path('bar')
assert env.load_path == ['foo', 'bar']
assert env.url_mapping == {'foo': '/foo'}
