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'}