def test_trace_app(self, mock):
"""
Test that tracing an app is delegated to the Node script.
"""
trace_result = {
'app/dummy.js': {
'name': 'app/dummy.js',
'timestamp': int(time.time()),
'path': 'app/dummy.js',
'skip': False,
}
}
return_value = (json.dumps(trace_result), '') # no stdout, no stderr
process_mock = mock_Popen(mock, return_value=return_value)
tracer = SystemTracer()
tracer.trace('app/dummy')
self.assertEqual(mock.call_count, 1)
self.assertEqual(mock.call_args[0], ('trace-deps.js app/dummy', ))
self.assertEqual(process_mock.communicate.call_count, 1)
# check the cache functionality - once an app was traced, the result
# should be stored on the tracer instance
tracer.trace('app/dummy')
self.assertEqual(mock.call_count, 1) # should still be only one
self.assertEqual(process_mock.communicate.call_count, 1)
def test_trace_app(self, mock):
"""
Test that tracing an app is delegated to the Node script.
"""
trace_result = {
'app/dummy.js': {
'name': 'app/dummy.js',
'timestamp': int(time.time()),
'path': 'app/dummy.js',
'skip': False,
}
}
return_value = (json.dumps(trace_result), '') # no stdout, no stderr
process_mock = mock_Popen(mock, return_value=return_value)
tracer = SystemTracer()
tracer.trace('app/dummy')
self.assertEqual(mock.call_count, 1)
self.assertEqual(mock.call_args[0], ('trace-deps.js app/dummy',))
self.assertEqual(process_mock.communicate.call_count, 1)
# check the cache functionality - once an app was traced, the result
# should be stored on the tracer instance
tracer.trace('app/dummy')
self.assertEqual(mock.call_count, 1) # should still be only one
self.assertEqual(process_mock.communicate.call_count, 1)
def test_write_deps_external_resource(self, mock):
"""
Issue #13: google maps is scriptLoaded and has no physical file on disk.
As such, there is no `info['path']` to read.
"""
now = int(time.time())
trace_result = {
'app/dummy.js': {
'name': 'app/dummy.js',
'timestamp': now,
'path': 'app/dummy.js',
'skip': False,
},
'google-maps': {
'name': 'google-maps',
'path': None,
'timestamp': None,
'skip': True,
},
}
return_value = (json.dumps(trace_result), '') # no stdout, no stderr
mock_Popen(mock, return_value=return_value)
tracer = SystemTracer()
all_deps = {'app/dummy': tracer.trace('app/dummy')}
path = os.path.join(settings.SYSTEMJS_CACHE_DIR, 'deps.json')
self.assertFalse(os.path.exists(path))
tracer.write_depcache(all_deps, {})
self.assertTrue(os.path.exists(path))
with open(path) as infile:
depcache = json.load(infile)
# google maps may not be included
self.assertEqual(list(depcache['packages'].keys()), ['app/dummy'])
def test_write_deps(self, mock):
"""
Trace an app and write the depcache for it.
"""
now = int(time.time())
trace_result = {
'app/dummy.js': {
'name': 'app/dummy.js',
'timestamp': now,
'path': 'app/dummy.js',
'skip': False,
},
'app/dependency.js': {
'name': 'app/dependency.js',
'timestamp': now,
'path': 'app/dependency.js',
'skip': False,
}
}
return_value = (json.dumps(trace_result), '') # no stdout, no stderr
mock_Popen(mock, return_value=return_value)
tracer = SystemTracer()
all_deps = {'app/dummy': tracer.trace('app/dummy')}
path = os.path.join(settings.SYSTEMJS_CACHE_DIR, 'deps.json')
self.assertFalse(os.path.exists(path))
tracer.write_depcache(all_deps, {})
self.assertTrue(os.path.exists(path))
def test_write_deps_external_resource(self, mock):
"""
Issue #13: google maps is scriptLoaded and has no physical file on disk.
As such, there is no `info['path']` to read.
"""
now = int(time.time())
trace_result = {
'app/dummy.js': {
'name': 'app/dummy.js',
'timestamp': now,
'path': 'app/dummy.js',
'skip': False,
},
'google-maps': {
'name': 'google-maps',
'path': None,
'timestamp': None,
'skip': True,
},
}
return_value = (json.dumps(trace_result), '') # no stdout, no stderr
mock_Popen(mock, return_value=return_value)
tracer = SystemTracer()
all_deps = {'app/dummy': tracer.trace('app/dummy')}
path = os.path.join(settings.SYSTEMJS_CACHE_DIR, 'deps.json')
self.assertFalse(os.path.exists(path))
tracer.write_depcache(all_deps, {})
self.assertTrue(os.path.exists(path))
with open(path) as infile:
depcache = json.load(infile)
# google maps may not be included
self.assertEqual(list(depcache['packages'].keys()), ['app/dummy'])
def test_write_deps(self, mock):
"""
Trace an app and write the depcache for it.
"""
now = int(time.time())
trace_result = {
'app/dummy.js': {
'name': 'app/dummy.js',
'timestamp': now,
'path': 'app/dummy.js',
'skip': False,
},
'app/dependency.js': {
'name': 'app/dependency.js',
'timestamp': now,
'path': 'app/dependency.js',
'skip': False,
}
}
return_value = (json.dumps(trace_result), '') # no stdout, no stderr
mock_Popen(mock, return_value=return_value)
tracer = SystemTracer()
all_deps = {'app/dummy': tracer.trace('app/dummy')}
path = os.path.join(settings.SYSTEMJS_CACHE_DIR, 'deps.json')
self.assertFalse(os.path.exists(path))
tracer.write_depcache(all_deps, {})
self.assertTrue(os.path.exists(path))
def handle(self, **options):
super(Command, self).handle(**options)
system_opts = self.get_system_opts(options)
all_apps = self.find_apps(templates=options.get('templates'))
all_apps = set(sum(all_apps.values(), []))
tracer = SystemTracer(node_path=options.get('node_path'))
all_deps = {app: tracer.trace(app) for app in all_apps}
tracer.write_depcache(all_deps, system_opts)
def handle(self, **options):
super(Command, self).handle(**options)
system_opts = self.get_system_opts(options)
all_apps = self.find_apps(templates=options.get('templates'))
all_apps = set(sum(all_apps.values(), []))
tracer = SystemTracer(node_path=options.get('node_path'))
all_deps = {
app: tracer.trace(app) for app in all_apps
}
tracer.write_depcache(all_deps, system_opts)
def handle(self, **options):
super(Command, self).handle(**options)
self.post_process = options['post_process']
self.minimal = options.get('minimal')
self.verbosity = 2
self.storage = copy(staticfiles_storage)
self.storage.systemjs_bundling = True # set flag to check later
# initialize SystemJS specific objects to process the bundles
tracer = SystemTracer(node_path=options.get('node_path'))
system_opts = self.get_system_opts(options)
system = System(**system_opts)
has_different_options = self.minimal and tracer.get_bundle_options() != system_opts
# discover the apps being imported in the templates
all_apps = self.find_apps(templates=options.get('templates'))
all_apps = set(sum(all_apps.values(), []))
bundled_files = OrderedDict()
# FIXME: this should be configurable, if people use S3BotoStorage for example, it needs to end up there
storage = FileSystemStorage(settings.STATIC_ROOT, base_url=settings.STATIC_URL)
for app in all_apps:
# do we need to generate the bundle for this app?
if self.minimal and not (has_different_options or tracer.check_needs_update(app)):
# check if the bundle actually exists - if it doesn't, don't skip it
# this happens on the first ever bundle
bundle_path = System.get_bundle_path(app)
if self.storage.exists(bundle_path):
self.stdout.write('Checked bundle for app \'{app}\', no changes found'.format(app=app))
continue
rel_path = system.bundle(app)
if not self.storage.exists(rel_path):
self.stderr.write('Could not bundle {app}'.format(app=app))
else:
self.stdout.write('Bundled {app} into {out}'.format(app=app, out=rel_path))
bundled_files[rel_path] = (storage, rel_path)
if self.minimal and bundled_files:
self.stdout.write('Generating the new depcache and writing to file...')
all_deps = {app: tracer.trace(app) for app in all_apps}
tracer.write_depcache(all_deps, system_opts)
if self.post_process and hasattr(self.storage, 'post_process'):
# post-process system.js if it's within settings.STATIC_ROOT
systemjs_path = find_systemjs_location()
try:
within_static_root = self.storage.exists(systemjs_path)
except SuspiciousFileOperation:
within_static_root = False
if within_static_root:
relative = os.path.relpath(systemjs_path, settings.STATIC_ROOT)
bundled_files[relative] = (storage, relative)
processor = self.storage.post_process(bundled_files, dry_run=False)
for original_path, processed_path, processed in processor:
if isinstance(processed, Exception): # pragma: no cover
self.stderr.write("Post-processing '%s' failed!" % original_path)
# Add a blank line before the traceback, otherwise it's
# too easy to miss the relevant part of the error message.
self.stderr.write("")
raise processed
if processed: # pragma: no cover
self.log("Post-processed '%s' as '%s'" % (original_path, processed_path), level=1)
else:
self.log("Skipped post-processing '%s'" % original_path) # pragma: no cover
