def test_a_manifest_can_be_generated_with_multiple_contexts(self):
manifest = generate_manifest({
ConfigFiles.BASIC_CONFIG: (
{'foo': 'bar'},
),
ConfigFiles.LIBRARY_CONFIG: (
{'foo': 'bar'},
{'woz': 'woo'},
),
})
self.assertIsInstance(manifest, dict)
self.assertEqual(len(manifest.keys()), 3)
key1 = generate_key(ConfigFiles.BASIC_CONFIG, {'foo': 'bar'})
self.assertIn(key1, manifest)
entry1 = manifest[key1]
bundle1 = webpack(ConfigFiles.BASIC_CONFIG, context={'foo': 'bar'})
self.assertEqual(entry1, bundle1.data)
key2 = generate_key(ConfigFiles.LIBRARY_CONFIG, {'foo': 'bar'})
self.assertIn(key2, manifest)
entry2 = manifest[key2]
bundle2 = webpack(ConfigFiles.LIBRARY_CONFIG, context={'foo': 'bar'})
self.assertEqual(entry2, bundle2.data)
key3 = generate_key(ConfigFiles.LIBRARY_CONFIG, {'woz': 'woo'})
self.assertIn(key3, manifest)
entry3 = manifest[key3]
bundle3 = webpack(ConfigFiles.LIBRARY_CONFIG, context={'woz': 'woo'})
self.assertEqual(entry3, bundle3.data)
def test_source_files_can_be_watched_to_rebuild_a_bundle(self):
self.assertEqual(read_file(PATH_TO_WATCHED_SOURCE_ENTRY),
WATCHED_SOURCE_CONTENT)
bundle = webpack(PATH_TO_WATCHED_SOURCE_CONFIG,
settings={'WATCH': True})
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0])
self.assertIn('__DJANGO_WEBPACK_WATCH_SOURCE_ONE__', contents)
self.assertNotIn('__DJANGO_WEBPACK_WATCH_SOURCE_TWO__', contents)
time.sleep(WATCH_WAIT)
write_file(
PATH_TO_WATCHED_SOURCE_ENTRY,
"""module.exports = '__DJANGO_WEBPACK_WATCH_SOURCE_TWO__';""")
time.sleep(WATCH_WAIT)
bundle = webpack(PATH_TO_WATCHED_SOURCE_CONFIG,
settings={'WATCH': True})
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0])
self.assertNotIn('__DJANGO_WEBPACK_WATCH_SOURCE_ONE__', contents)
self.assertIn('__DJANGO_WEBPACK_WATCH_SOURCE_TWO__', contents)
def test_config_file_can_be_watched_to_rebuild_the_bundle(self):
self.assertIn('./entry1.js', WATCHED_CONFIG_CONTENT)
self.assertEqual(read_file(PATH_TO_WATCHED_CONFIG), WATCHED_CONFIG_CONTENT)
bundle = webpack(PATH_TO_WATCHED_CONFIG, watch_config=True)
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0]['path'])
self.assertIn('__DJANGO_WEBPACK_WATCH_CONFIG_ONE__', contents)
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_TWO__', contents)
time.sleep(WATCH_WAIT)
changed_config = WATCHED_CONFIG_CONTENT.replace('./entry1.js', './entry2.js')
self.assertNotIn('./entry1.js', changed_config)
write_file(PATH_TO_WATCHED_CONFIG, changed_config)
time.sleep(WATCH_WAIT)
bundle = webpack(PATH_TO_WATCHED_CONFIG, watch_config=True)
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0]['path'])
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_ONE__', contents)
self.assertIn('__DJANGO_WEBPACK_WATCH_CONFIG_TWO__', contents)
def test_a_manifest_can_be_generated_with_multiple_contexts(self):
manifest = generate_manifest({
ConfigFiles.BASIC_CONFIG: ({
'foo': 'bar'
}, ),
ConfigFiles.LIBRARY_CONFIG: (
{
'foo': 'bar'
},
{
'woz': 'woo'
},
),
})
self.assertIsInstance(manifest, dict)
self.assertEqual(len(manifest.keys()), 3)
key1 = generate_key(ConfigFiles.BASIC_CONFIG, {'foo': 'bar'})
self.assertIn(key1, manifest)
entry1 = manifest[key1]
bundle1 = webpack(ConfigFiles.BASIC_CONFIG, context={'foo': 'bar'})
self.assertEqual(entry1, bundle1.data)
key2 = generate_key(ConfigFiles.LIBRARY_CONFIG, {'foo': 'bar'})
self.assertIn(key2, manifest)
entry2 = manifest[key2]
bundle2 = webpack(ConfigFiles.LIBRARY_CONFIG, context={'foo': 'bar'})
self.assertEqual(entry2, bundle2.data)
key3 = generate_key(ConfigFiles.LIBRARY_CONFIG, {'woz': 'woo'})
self.assertIn(key3, manifest)
entry3 = manifest[key3]
bundle3 = webpack(ConfigFiles.LIBRARY_CONFIG, context={'woz': 'woo'})
self.assertEqual(entry3, bundle3.data)
def index():
config_file = os.path.join(BASE_DIR, 'example.webpack.js')
component = os.path.join(BASE_DIR, 'app', 'CommentBox.jsx')
props = {
'comments': comments,
'url': '/comment/',
}
rendered = render_component(component, props)
webpack_context = {
'component': component,
'props_var': 'window.mountProps',
'container': 'mount-container',
}
bundle = webpack(config_file, context=webpack_context)
return render_template(
'index.html',
bundle=bundle,
webpack_context=webpack_context,
rendered=rendered,
)
def test_can_render_a_webpack_bundle(self):
bundle = webpack(PATH_TO_BASIC_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 1)
rendered = bundle.render()
self.assertIn(urls[0], rendered)
self.assertEqual(rendered, '<script src="' + urls[0] + '"></script>')
def test_can_render_a_bundle_with_multiple_entries(self):
bundle = webpack(PATH_TO_MULTIPLE_ENTRY_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 1)
rendered = bundle.render()
self.assertIn(urls[0], rendered)
self.assertEqual(rendered, '<script src="' + urls[0] + '"></script>')
def test_can_render_a_bundle_with_multiple_entry_points(self):
bundle = webpack(ConfigFiles.MULTIPLE_ENTRY_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 1)
rendered = bundle.render_js()
self.assertIn(urls['main']['js'][0], rendered)
self.assertEqual(rendered, '<script src="' + urls['main']['js'][0] + '"></script>')
def test_can_render_a_bundle_with_multiple_entries(self):
bundle = webpack(PATH_TO_MULTIPLE_ENTRY_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 1)
rendered = bundle.render()
self.assertIn(urls[0], rendered)
self.assertEqual(rendered, '<script src="' + urls[0] + '"></script>')
def test_can_render_a_webpack_bundle(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls['main']['js']), 1)
rendered = bundle.render_js()
self.assertIn(urls['main']['js'][0], rendered)
self.assertEqual(rendered, '<script src="' + urls['main']['js'][0] + '"></script>')
def test_bundle_create_a_file_with_contents(self):
bundle = webpack(PATH_TO_BASIC_CONFIG)
assets = bundle.get_assets()
self.assertEqual(len(assets), 1)
asset = assets[0]
paths = bundle.get_paths()
self.assertEqual(paths[0], asset['path'])
self.assertTrue(asset['name'].startswith('bundle-'))
self.assertTrue(asset['name'].endswith('.js'))
self.assertEqual(
asset['path'],
os.path.join(settings.get_path_to_bundle_dir(), asset['name']))
self.assertTrue(os.path.exists(asset['path']))
self.assertTrue(
os.path.exists(
os.path.join(settings.get_path_to_bundle_dir(),
asset['name'])))
self.assertEqual(
asset['url'],
(settings.BUNDLE_URL + settings.OUTPUT_DIR + '/' +
settings.BUNDLE_DIR + '/' + asset['name']).replace('\\', '/'),
)
contents = read_file(asset['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', contents)
self.assertIn('__DJANGO_WEBPACK_REQUIRE_TEST__', contents)
def index():
config_file = os.path.join(BASE_DIR, 'example.webpack.js')
component = os.path.join(BASE_DIR, 'app', 'CommentBox.jsx')
props = {
'comments': comments,
'url': '/comment/',
}
rendered = render_component(component, props)
webpack_context = {
'component': component,
'props_var': 'window.mountProps',
'container': 'mount-container',
}
bundle = webpack(config_file, context=webpack_context)
return render_template(
'index.html',
bundle=bundle,
webpack_context=webpack_context,
rendered=rendered,
)
def bundle_component(path, client_path, translate=None, path_to_react=None, devtool=None, client=False):
if not os.path.isabs(path):
abs_path = staticfiles.find(path)
if not abs_path:
raise ComponentSourceFileNotFound(path)
path = abs_path
if not os.path.exists(path):
raise ComponentSourceFileNotFound(path)
if not os.path.isabs(client_path):
abs_client_path = staticfiles.find(client_path)
if not abs_client_path:
raise ComponentSourceFileNotFound(client_path)
client_path = abs_client_path
if not os.path.exists(client_path):
raise ComponentSourceFileNotFound(client_path)
config = generate_config_for_component(path, client_path, translate=translate, path_to_react=path_to_react, devtool=devtool)
config_file = generate_config_file(config)
var = generate_var_from_path(client_path)
path_to_config_file = get_path_to_config_file(config_file, prefix=var + '.')
return webpack(path_to_config_file)
def test_bundle_urls_can_be_resolved_via_the_static_file_finder_used_by_the_dev_server(
self):
bundle = webpack('django_test_app/webpack.config.js')
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
relative_url = assets[0]['url'].split('/static/')[-1]
self.assertEqual(staticfiles.find(relative_url), assets[0]['path'])
def test_bundle_can_resolve_files_via_the_django_static_file_finder(self):
bundle = webpack('django_test_app/webpack.config.js')
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0]['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', contents)
self.assertIn('__DJANGO_WEBPACK_STATIC_FILE_FINDER_TEST__', contents)
def test_bundle_create_a_file_with_contents(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
assets = bundle.get_assets()
self.assertEqual(len(assets), 1)
asset = assets[0]
output = bundle.get_output()['main']['js'][0]
self.assertEqual(asset, output)
self.assertEqual(
asset,
os.path.join(
settings.get_path_to_output_dir(),
bundle.options['__python_webpack_hash__'],
'bundle-{}.js'.format(bundle.data['stats']['hash'])
)
)
self.assertTrue(os.path.exists(asset))
self.assertEqual(
bundle.get_urls()['main']['js'][0],
(
settings.STATIC_URL +
settings.OUTPUT_DIR +
'/' +
bundle.options['__python_webpack_hash__'] +
'/' +
'bundle-{}.js'.format(bundle.data['stats']['hash'])
).replace('\\', '/'),
)
contents = read_file(asset)
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', contents)
self.assertIn('__DJANGO_WEBPACK_REQUIRE_TEST__', contents)
def test_can_render_a_webpack_bundle(self):
bundle = webpack(PATH_TO_BASIC_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 1)
rendered = bundle.render()
self.assertIn(urls[0], rendered)
self.assertEqual(rendered, '<script src="' + urls[0] + '"></script>')
def test_bundle_can_expose_its_output_options(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
output_options = bundle.get_output_options()
self.assertEqual(output_options['filename'], 'bundle-[hash].js')
self.assertEqual(
output_options['path'],
os.path.join(settings.STATIC_ROOT, settings.OUTPUT_DIR,
bundle.options['__python_webpack_hash__']))
def test_bundle_can_render_multiple_bundles(self):
bundle = webpack(PATH_TO_MULTIPLE_BUNDLES_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 2)
rendered = bundle.render()
for url in urls:
self.assertIn(url, bundle.render())
self.assertEqual(rendered, '<script src="' + urls[0] + '"></script><script src="' + urls[1] + '"></script>')
def test_bundle_urls_can_be_resolved_via_the_static_file_finder_used_by_the_dev_server(
self):
bundle = webpack('django_test_app/webpack.config.js')
urls = bundle.get_urls()
self.assertTrue(len(urls['main']['js']), 1)
relative_url = urls['main']['js'][0].split('/static/')[-1]
self.assertEqual(staticfiles.find(relative_url),
bundle.get_assets()[0])
def test_can_render_a_bundle_with_multiple_entry_points(self):
bundle = webpack(ConfigFiles.MULTIPLE_ENTRY_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 1)
rendered = bundle.render_js()
self.assertIn(urls['main']['js'][0], rendered)
self.assertEqual(
rendered, '<script src="' + urls['main']['js'][0] + '"></script>')
def test_can_render_a_webpack_bundle(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls['main']['js']), 1)
rendered = bundle.render_js()
self.assertIn(urls['main']['js'][0], rendered)
self.assertEqual(
rendered, '<script src="' + urls['main']['js'][0] + '"></script>')
def test_webpack_bundles_can_return_urls_to_assets(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
assets = bundle.get_assets()
urls = bundle.get_urls()
self.assertTrue(len(urls['main']['js']), 1)
self.assertEqual(
urls['main']['js'][0],
'/static/webpack_assets/' + bundle.options['__python_webpack_hash__'] + '/' + os.path.basename(assets[0]),
)
def test_bundle_can_expose_the_bundling_processes_output(self):
bundle = webpack(PATH_TO_LIBRARY_CONFIG)
stats = bundle.stats
self.assertIsInstance(stats, dict)
self.assertIn('webpackConfig', stats)
self.assertIsInstance(stats['webpackConfig'], dict)
self.assertIn('pathsToAssets', stats)
self.assertIsInstance(stats['pathsToAssets'], dict)
self.assertIn('urlsToAssets', stats)
self.assertIsInstance(stats['urlsToAssets'], dict)
def test_bundle_can_render_multiple_bundles(self):
bundle = webpack(PATH_TO_MULTIPLE_BUNDLES_CONFIG)
urls = bundle.get_urls()
self.assertTrue(len(urls), 2)
rendered = bundle.render()
for url in urls:
self.assertIn(url, bundle.render())
self.assertEqual(
rendered, '<script src="' + urls[0] + '"></script><script src="' +
urls[1] + '"></script>')
def test_bundle_can_expose_the_bundling_processes_output(self):
bundle = webpack(PATH_TO_LIBRARY_CONFIG)
stats = bundle.stats
self.assertIsInstance(stats, dict)
self.assertIn('webpackConfig', stats)
self.assertIsInstance(stats['webpackConfig'], dict)
self.assertIn('pathsToAssets', stats)
self.assertIsInstance(stats['pathsToAssets'], dict)
self.assertIn('urlsToAssets', stats)
self.assertIsInstance(stats['urlsToAssets'], dict)
def test_default_context_can_be_extended(self):
bundle = webpack(
ConfigFiles.LIBRARY_CONFIG,
context={'foo': 'bar'},
)
self.assertIn('default_context',
bundle.data['buildOptions']['context'])
self.assertEqual(
bundle.data['buildOptions']['context']['default_context'], 'test')
self.assertIn('foo', bundle.data['buildOptions']['context'])
self.assertEqual(bundle.data['buildOptions']['context']['foo'], 'bar')
def test_webpack_bundles_can_return_urls_to_assets(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
assets = bundle.get_assets()
urls = bundle.get_urls()
self.assertTrue(len(urls['main']['js']), 1)
self.assertEqual(
urls['main']['js'][0],
'/static/webpack_assets/' +
bundle.options['__python_webpack_hash__'] + '/' +
os.path.basename(assets[0]),
)
def test_bundle_can_handle_a_bundle_with_multiple_entries(self):
bundle = webpack(ConfigFiles.MULTIPLE_ENTRY_CONFIG)
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_ONE__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_TWO__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_THREE__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_FOUR__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_FIVE__', contents)
def test_a_manifest_can_be_generated_from_a_dictionary(self):
manifest = generate_manifest({ConfigFiles.BASIC_CONFIG: ()})
self.assertIsInstance(manifest, dict)
self.assertEqual(len(manifest.keys()), 1)
key = generate_key(ConfigFiles.BASIC_CONFIG)
self.assertIn(key, manifest)
entry = manifest[key]
bundle = webpack(ConfigFiles.BASIC_CONFIG)
self.assertEqual(entry, bundle.data)
def test_bundle_can_handle_a_bundle_with_multiple_entries(self):
bundle = webpack(PATH_TO_MULTIPLE_ENTRY_CONFIG)
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0]['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_ONE__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_TWO__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_THREE__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_FOUR__', contents)
self.assertIn('__DJANGO_WEBPACK_ENTRY_FIVE__', contents)
def test_default_context_can_be_extended(self):
bundle = webpack(
ConfigFiles.LIBRARY_CONFIG,
context={
'foo': 'bar'
},
)
self.assertIn('default_context', bundle.data['buildOptions']['context'])
self.assertEqual(bundle.data['buildOptions']['context']['default_context'], 'test')
self.assertIn('foo', bundle.data['buildOptions']['context'])
self.assertEqual(bundle.data['buildOptions']['context']['foo'], 'bar')
def test_a_manifest_can_be_generated_from_multiple_config_files_in_a_dictionary(self):
manifest = generate_manifest({
ConfigFiles.BASIC_CONFIG: (),
ConfigFiles.LIBRARY_CONFIG: (),
})
self.assertIsInstance(manifest, dict)
self.assertEqual(len(manifest.keys()), 2)
key1 = generate_key(ConfigFiles.BASIC_CONFIG)
self.assertIn(key1, manifest)
entry1 = manifest[key1]
bundle1 = webpack(ConfigFiles.BASIC_CONFIG)
self.assertEqual(entry1, bundle1.data)
key2 = generate_key(ConfigFiles.LIBRARY_CONFIG)
self.assertIn(key2, manifest)
entry2 = manifest[key2]
bundle2 = webpack(ConfigFiles.LIBRARY_CONFIG)
self.assertEqual(entry2, bundle2.data)
def test_a_manifest_can_be_generated_from_multiple_config_files(self):
manifest = generate_manifest((
ConfigFiles.BASIC_CONFIG,
ConfigFiles.LIBRARY_CONFIG,
), )
self.assertIsInstance(manifest, dict)
self.assertEqual(len(manifest.keys()), 2)
key1 = generate_key(ConfigFiles.BASIC_CONFIG)
self.assertIn(key1, manifest)
entry1 = manifest[key1]
bundle1 = webpack(ConfigFiles.BASIC_CONFIG)
self.assertEqual(entry1, bundle1.data)
key2 = generate_key(ConfigFiles.LIBRARY_CONFIG)
self.assertIn(key2, manifest)
entry2 = manifest[key2]
bundle2 = webpack(ConfigFiles.LIBRARY_CONFIG)
self.assertEqual(entry2, bundle2.data)
def test_bundle_can_expose_its_output_options(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
output_options = bundle.get_output_options()
self.assertEqual(output_options['filename'], 'bundle-[hash].js')
self.assertEqual(
output_options['path'],
os.path.join(
settings.STATIC_ROOT,
settings.OUTPUT_DIR,
bundle.options['__python_webpack_hash__']
)
)
def test_source_and_config_files_can_be_watched_to_rebuild_a_bundle(self):
self.assertEqual(read_file(PATH_TO_WATCHED_SOURCE_AND_CONFIG_CONFIG), WATCHED_SOURCE_AND_CONFIG_CONFIG_CONTENT)
bundle = webpack(PATH_TO_WATCHED_SOURCE_AND_CONFIG_CONFIG, watch_config=True, watch_source=True)
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0]['path'])
self.assertIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_ONE__', contents)
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_TWO__', contents)
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_THREE__', contents)
time.sleep(WATCH_WAIT)
changed_config = WATCHED_SOURCE_AND_CONFIG_CONFIG_CONTENT.replace('./entry1.js', './entry2.js')
self.assertNotIn('./entry1.js', changed_config)
write_file(PATH_TO_WATCHED_SOURCE_AND_CONFIG_CONFIG, changed_config)
time.sleep(WATCH_WAIT)
bundle = webpack(PATH_TO_WATCHED_SOURCE_AND_CONFIG_CONFIG, watch_config=True, watch_source=True)
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0]['path'])
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_ONE__', contents)
self.assertIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_TWO__', contents)
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_THREE__', contents)
time.sleep(WATCH_WAIT)
changed_source = """module.exports = '__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_THREE__';"""
write_file(PATH_TO_WATCHED_SOURCE_AND_CONFIG_ENTRY, changed_source)
time.sleep(WATCH_WAIT)
bundle = webpack(PATH_TO_WATCHED_SOURCE_AND_CONFIG_CONFIG, watch_config=True, watch_source=True)
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0]['path'])
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_ONE__', contents)
self.assertNotIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_TWO__', contents)
self.assertIn('__DJANGO_WEBPACK_WATCH_CONFIG_AND_SOURCE_THREE__', contents)
def test_source_files_can_be_watched_to_rebuild_a_bundle(self):
self.assertEqual(read_file(PATH_TO_WATCHED_SOURCE_ENTRY), WATCHED_SOURCE_CONTENT)
bundle = webpack(PATH_TO_WATCHED_SOURCE_CONFIG, settings={'WATCH': True})
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0])
self.assertIn('__DJANGO_WEBPACK_WATCH_SOURCE_ONE__', contents)
self.assertNotIn('__DJANGO_WEBPACK_WATCH_SOURCE_TWO__', contents)
time.sleep(WATCH_WAIT)
write_file(PATH_TO_WATCHED_SOURCE_ENTRY, """module.exports = '__DJANGO_WEBPACK_WATCH_SOURCE_TWO__';""")
time.sleep(WATCH_WAIT)
bundle = webpack(PATH_TO_WATCHED_SOURCE_CONFIG, settings={'WATCH': True})
assets = bundle.get_assets()
self.assertTrue(len(assets), 1)
contents = read_file(assets[0])
self.assertNotIn('__DJANGO_WEBPACK_WATCH_SOURCE_ONE__', contents)
self.assertIn('__DJANGO_WEBPACK_WATCH_SOURCE_TWO__', contents)
def test_a_manifest_can_be_generated_from_a_dictionary(self):
manifest = generate_manifest({
ConfigFiles.BASIC_CONFIG: ()
})
self.assertIsInstance(manifest, dict)
self.assertEqual(len(manifest.keys()), 1)
key = generate_key(ConfigFiles.BASIC_CONFIG)
self.assertIn(key, manifest)
entry = manifest[key]
bundle = webpack(ConfigFiles.BASIC_CONFIG)
self.assertEqual(entry, bundle.data)
def test_bundle_can_expose_the_bundling_processes_output(self):
bundle = webpack(ConfigFiles.LIBRARY_CONFIG)
data = bundle.data
self.assertIsInstance(data, dict)
self.assertIn('stats', data)
self.assertIsInstance(data['stats'], dict)
self.assertIn('outputOptions', data)
self.assertIsInstance(data['outputOptions'], dict)
self.assertIn('assets', data)
self.assertIsInstance(data['assets'], list)
self.assertIn('output', data)
self.assertIsInstance(data['output'], dict)
self.assertIn('urls', data)
self.assertIsInstance(data['urls'], dict)
def test_bundle_can_expose_the_bundling_processes_output(self):
bundle = webpack(ConfigFiles.LIBRARY_CONFIG)
data = bundle.data
self.assertIsInstance(data, dict)
self.assertIn('stats', data)
self.assertIsInstance(data['stats'], dict)
self.assertIn('outputOptions', data)
self.assertIsInstance(data['outputOptions'], dict)
self.assertIn('assets', data)
self.assertIsInstance(data['assets'], list)
self.assertIn('output', data)
self.assertIsInstance(data['output'], dict)
self.assertIn('urls', data)
self.assertIsInstance(data['urls'], dict)
def test_bundle_can_render_multiple_entries(self):
bundle = webpack(ConfigFiles.MULTIPLE_BUNDLES_CONFIG)
assets = bundle.get_assets()
self.assertTrue(len(assets), 2)
urls = bundle.get_urls()
rendered = bundle.render_js()
self.assertIn(urls['bundle_1']['js'][0], bundle.render_js())
self.assertIn(urls['bundle_2']['js'][0], bundle.render_js())
self.assertIn(
'<script src="' + urls['bundle_1']['js'][0] + '"></script>',
rendered)
self.assertIn('\n', rendered)
self.assertIn(
'<script src="' + urls['bundle_2']['js'][0] + '"></script>',
rendered)
def test_bundle_can_expose_its_config(self):
bundle = webpack(PATH_TO_BASIC_CONFIG)
config = bundle.get_config()
self.assertDictContainsSubset(
{
'context': os.path.join(BUNDLES, 'basic', 'app'),
'entry': './entry.js',
}, config)
self.assertDictContainsSubset(
{
'path':
os.path.join(settings.BUNDLE_ROOT, settings.OUTPUT_DIR,
settings.BUNDLE_DIR),
'filename':
'bundle-[hash].js'
}, config['output'])
def test_bundle_can_render_multiple_entries(self):
bundle = webpack(ConfigFiles.MULTIPLE_BUNDLES_CONFIG)
assets = bundle.get_assets()
self.assertTrue(len(assets), 2)
urls = bundle.get_urls()
rendered = bundle.render_js()
self.assertIn(
urls['bundle_1']['js'][0],
bundle.render_js()
)
self.assertIn(
urls['bundle_2']['js'][0],
bundle.render_js()
)
self.assertIn('<script src="' + urls['bundle_1']['js'][0] + '"></script>', rendered)
self.assertIn('\n', rendered)
self.assertIn('<script src="' + urls['bundle_2']['js'][0] + '"></script>', rendered)
def test_bundle_can_expose_its_config(self):
bundle = webpack(PATH_TO_BASIC_CONFIG)
config = bundle.get_config()
self.assertDictContainsSubset(
{
'context': os.path.join(BUNDLES, 'basic', 'app'),
'entry': './entry.js',
},
config
)
self.assertDictContainsSubset(
{
'path': os.path.join(settings.BUNDLE_ROOT, settings.OUTPUT_DIR, settings.BUNDLE_DIR),
'filename': 'bundle-[hash].js'
},
config['output']
)
def bundle_component(path, translate=None, devtool=None):
if not os.path.isabs(path):
abs_path = staticfiles.find(path)
if not abs_path:
raise ComponentSourceFileNotFound(path)
path = abs_path
if not os.path.exists(path):
raise ComponentSourceFileNotFound(path)
config = generate_config_for_component(path, translate=translate, devtool=devtool)
config_file = generate_config_file(config)
var = generate_var_from_path(path)
path_to_config_file = get_path_to_config_file(config_file, prefix=var + '.')
return webpack(path_to_config_file)
def test_bundle_can_handle_multiple_bundles(self):
bundle = webpack(PATH_TO_MULTIPLE_BUNDLES_CONFIG)
assets = bundle.get_assets()
self.assertTrue(len(assets), 2)
asset_names = [asset['name'] for asset in assets]
self.assertIn('bundle-bundle_1.js', asset_names)
self.assertIn('bundle-bundle_2.js', asset_names)
bundle_1 = [asset for asset in assets if asset['name'] == 'bundle-bundle_1.js'][0]
bundle_2 = [asset for asset in assets if asset['name'] == 'bundle-bundle_2.js'][0]
self.assertEqual(bundle_1['name'], 'bundle-bundle_1.js')
self.assertEqual(bundle_2['name'], 'bundle-bundle_2.js')
bundle_1_contents = read_file(bundle_1['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_1_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_1_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_1_contents)
bundle_2_contents = read_file(bundle_2['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_2_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_2_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_2_contents)
def test_bundle_can_handle_multiple_bundles(self):
bundle = webpack(ConfigFiles.MULTIPLE_BUNDLES_CONFIG)
assets = bundle.get_assets()
output = bundle.get_output()
urls = bundle.get_urls()
self.assertTrue(len(assets), 2)
self.assertIn('bundle-bundle_1.js', output['bundle_1']['js'][0])
self.assertIn('bundle-bundle_2.js', output['bundle_2']['js'][0])
self.assertIn('bundle_1', output)
self.assertIn('bundle_2', output)
self.assertIn('bundle_1', urls)
self.assertIn('bundle_2', urls)
bundle_1_contents = read_file(output['bundle_1']['js'][0])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_1_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_1_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_1_contents)
bundle_2_contents = read_file(output['bundle_2']['js'][0])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_2_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_2_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_2_contents)
def test_bundle_can_handle_multiple_bundles(self):
bundle = webpack(ConfigFiles.MULTIPLE_BUNDLES_CONFIG)
assets = bundle.get_assets()
output = bundle.get_output()
urls = bundle.get_urls()
self.assertTrue(len(assets), 2)
self.assertIn('bundle-bundle_1.js', output['bundle_1']['js'][0])
self.assertIn('bundle-bundle_2.js', output['bundle_2']['js'][0])
self.assertIn('bundle_1', output)
self.assertIn('bundle_2', output)
self.assertIn('bundle_1', urls)
self.assertIn('bundle_2', urls)
bundle_1_contents = read_file(output['bundle_1']['js'][0])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_1_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_1_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_1_contents)
bundle_2_contents = read_file(output['bundle_2']['js'][0])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_2_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_2_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_2_contents)
def test_bundle_create_a_file_with_contents(self):
bundle = webpack(PATH_TO_BASIC_CONFIG)
assets = bundle.get_assets()
self.assertEqual(len(assets), 1)
asset = assets[0]
paths = bundle.get_paths()
self.assertEqual(paths[0], asset['path'])
self.assertTrue(asset['name'].startswith('bundle-'))
self.assertTrue(asset['name'].endswith('.js'))
self.assertEqual(
asset['path'],
os.path.join(settings.get_path_to_bundle_dir(), asset['name'])
)
self.assertTrue(os.path.exists(asset['path']))
self.assertTrue(os.path.exists(os.path.join(settings.get_path_to_bundle_dir(), asset['name'])))
self.assertEqual(
asset['url'],
(settings.BUNDLE_URL + settings.OUTPUT_DIR + '/' + settings.BUNDLE_DIR + '/' + asset['name']).replace('\\', '/'),
)
contents = read_file(asset['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', contents)
self.assertIn('__DJANGO_WEBPACK_REQUIRE_TEST__', contents)
def test_the_manifest_is_used_by_the_compiler(self):
manifest = generate_manifest({
ConfigFiles.BASIC_CONFIG: (),
})
key = generate_key(ConfigFiles.BASIC_CONFIG)
self.assertIn(key, manifest)
path = os.path.join(STATIC_ROOT, 'test_manifest.json')
write_manifest(path, manifest)
with mock.patch('webpack.compiler.build_server.build',
self._raise_if_called):
mock_settings = Conf()
mock_settings.configure(**dict(
WEBPACK,
USE_MANIFEST=True,
MANIFEST_PATH=path,
))
with mock.patch('webpack.conf.settings', mock_settings):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
self.assertEqual(bundle.data, manifest[key])
def test_bundle_create_a_file_with_contents(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
assets = bundle.get_assets()
self.assertEqual(len(assets), 1)
asset = assets[0]
output = bundle.get_output()['main']['js'][0]
self.assertEqual(asset, output)
self.assertEqual(
asset,
os.path.join(settings.get_path_to_output_dir(),
bundle.options['__python_webpack_hash__'],
'bundle-{}.js'.format(bundle.data['stats']['hash'])))
self.assertTrue(os.path.exists(asset))
self.assertEqual(
bundle.get_urls()['main']['js'][0],
(settings.STATIC_URL + settings.OUTPUT_DIR + '/' +
bundle.options['__python_webpack_hash__'] + '/' +
'bundle-{}.js'.format(bundle.data['stats']['hash'])).replace(
'\\', '/'),
)
contents = read_file(asset)
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', contents)
self.assertIn('__DJANGO_WEBPACK_REQUIRE_TEST__', contents)
def test_bundle_can_handle_multiple_bundles(self):
bundle = webpack(PATH_TO_MULTIPLE_BUNDLES_CONFIG)
assets = bundle.get_assets()
self.assertTrue(len(assets), 2)
asset_names = [asset['name'] for asset in assets]
self.assertIn('bundle-bundle_1.js', asset_names)
self.assertIn('bundle-bundle_2.js', asset_names)
bundle_1 = [
asset for asset in assets if asset['name'] == 'bundle-bundle_1.js'
][0]
bundle_2 = [
asset for asset in assets if asset['name'] == 'bundle-bundle_2.js'
][0]
self.assertEqual(bundle_1['name'], 'bundle-bundle_1.js')
self.assertEqual(bundle_2['name'], 'bundle-bundle_2.js')
bundle_1_contents = read_file(bundle_1['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_1_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_1_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_1_contents)
bundle_2_contents = read_file(bundle_2['path'])
self.assertIn('__DJANGO_WEBPACK_ENTRY_TEST__', bundle_2_contents)
self.assertNotIn('__DJANGO_WEBPACK_BUNDLE_ONE__', bundle_2_contents)
self.assertIn('__DJANGO_WEBPACK_BUNDLE_TWO__', bundle_2_contents)
def test_the_manifest_is_used_by_the_compiler(self):
manifest = generate_manifest({
ConfigFiles.BASIC_CONFIG: (),
})
key = generate_key(ConfigFiles.BASIC_CONFIG)
self.assertIn(key, manifest)
path = os.path.join(STATIC_ROOT, 'test_manifest.json')
write_manifest(path, manifest)
with mock.patch('webpack.compiler.build_server.build', self._raise_if_called):
mock_settings = Conf()
mock_settings.configure(
**dict(
WEBPACK,
USE_MANIFEST=True,
MANIFEST_PATH=path,
)
)
with mock.patch('webpack.conf.settings', mock_settings):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
self.assertEqual(bundle.data, manifest[key])
def get_context_data(self, **kwargs):
context = super(IndexView, self).get_context_data(**kwargs)
context['bundle'] = webpack('example.webpack.js')
return context
def test_webpack_returns_webpack_bundle_instances(self):
bundle = webpack(ConfigFiles.BASIC_CONFIG)
self.assertIsInstance(bundle, WebpackBundle)
def index():
return render_template(
'index.html',
# Send a request to the build server
bundle=webpack('example.webpack.js')
)
def test_bundle_urls_can_be_resolved_via_the_static_file_finder_used_by_the_dev_server(self):
bundle = webpack('django_test_app/webpack.config.js')
urls = bundle.get_urls()
self.assertTrue(len(urls['main']['js']), 1)
relative_url = urls['main']['js'][0].split('/static/')[-1]
self.assertEqual(staticfiles.find(relative_url), bundle.get_assets()[0])
