src/third_party/trace-viewer/third_party/tvcm/tvcm/html_module_unittest.py

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 import os
   6 import unittest
   7 import StringIO
   8
   9 from tvcm import fake_fs
  10 from tvcm import generate
  11 from tvcm import html_generation_controller
  12 from tvcm import html_module
  13 from tvcm import module
  14 from tvcm import parse_html_deps
  15 from tvcm import project as project_module
  16 from tvcm import resource
  17 from tvcm import resource_loader as resource_loader
  18 from tvcm import strip_js_comments
  19
  20 class ResourceWithFakeContents(resource.Resource):
  21   def __init__(self, toplevel_dir, absolute_path, fake_contents):
  22     """A resource with explicitly provided contents.
  23
  24     If the resource does not exist, then pass fake_contents=None. This will
  25     cause accessing the resource contents to raise an exception mimicking the
  26     behavior of regular resources."""
  27     super(ResourceWithFakeContents, self).__init__(toplevel_dir, absolute_path)
  28     self._fake_contents = fake_contents
  29
  30   @property
  31   def contents(self):
  32     if self._fake_contents == None:
  33       raise Exception('File not found')
  34     return self._fake_contents
  35
  36 class FakeLoader(object):
  37   def __init__(self, source_paths, initial_filenames_and_contents=None):
  38     self._source_paths = source_paths
  39     self._file_contents = {}
  40     if initial_filenames_and_contents:
  41       for k,v in initial_filenames_and_contents.iteritems():
  42         self._file_contents[k] = v
  43
  44   def FindResourceGivenAbsolutePath(self, absolute_path):
  45     candidate_paths = []
  46     for source_path in self._source_paths:
  47       if absolute_path.startswith(source_path):
  48         candidate_paths.append(source_path)
  49     if len(candidate_paths) == 0:
  50       return None
  51
  52     # Sort by length. Longest match wins.
  53     candidate_paths.sort(lambda x, y: len(x) - len(y))
  54     longest_candidate = candidate_paths[-1]
  55
  56     return ResourceWithFakeContents(longest_candidate, absolute_path,
  57                                     self._file_contents.get(absolute_path, None))
  58
  59   def FindResourceGivenRelativePath(self, relative_path):
  60     absolute_path = None
  61     for script_path in self._source_paths:
  62       absolute_path = os.path.join(script_path, relative_path)
  63       if absolute_path in self._file_contents:
  64         return ResourceWithFakeContents(script_path, absolute_path,
  65                                         self._file_contents[absolute_path])
  66     return None
  67
  68
  69 class ParseTests(unittest.TestCase):
  70   def testMissingDocType(self):
  71     parse_results = parse_html_deps.HTMLModuleParserResults("")
  72
  73     file_contents = {}
  74
  75     def DoIt():
  76       html_module.Parse(FakeLoader(["/tmp"], file_contents),
  77                         "a.b.start",
  78                         "/tmp/a/b/",
  79                         parse_results)
  80     self.assertRaises(Exception, DoIt)
  81
  82   def testValidExternalScriptReferenceToRawScript(self):
  83     parse_results = parse_html_deps.HTMLModuleParserResults("""<!DOCTYPE html>
  84       <script src="../foo.js">
  85       """)
  86
  87     file_contents = {}
  88     file_contents['/tmp/a/foo.js'] = """
  89 'i am just some raw script';
  90 """
  91
  92     metadata = html_module.Parse(FakeLoader(["/tmp"], file_contents),
  93                                  "a.b.start",
  94                                  "/tmp/a/b/",
  95                                  parse_results)
  96     self.assertEquals([], metadata.dependent_module_names)
  97     self.assertEquals(['a/foo.js'], metadata.dependent_raw_script_relative_paths)
  98
  99
 100   def testExternalScriptReferenceToModuleOutsideScriptPath(self):
 101     parse_results = parse_html_deps.HTMLModuleParserResults("""<!DOCTYPE html>
 102       <script src="/foo.js">
 103       """)
 104
 105     file_contents = {}
 106     file_contents['/foo.js'] = ''
 107
 108     def DoIt():
 109       html_module.Parse(FakeLoader(["/tmp"], file_contents),
 110                         "a.b.start",
 111                         "/tmp/a/b/",
 112                         parse_results)
 113     self.assertRaises(Exception, DoIt)
 114
 115   def testExternalScriptReferenceToFileThatDoesntExist(self):
 116     parse_results = parse_html_deps.HTMLModuleParserResults("""<!DOCTYPE html>
 117       <script src="/foo.js">
 118       """)
 119
 120     file_contents = {}
 121
 122     def DoIt():
 123       html_module.Parse(FakeLoader(["/tmp"], file_contents),
 124                         "a.b.start",
 125                         "/tmp/a/b/",
 126                         parse_results)
 127     self.assertRaises(Exception, DoIt)
 128
 129   def testInlineScriptWithoutStrictNote(self):
 130     parse_results = parse_html_deps.HTMLModuleParserResults("""<!DOCTYPE html>
 131       <script>
 132 console.log('Logging without strict mode is no fun.');
 133       </script>
 134       """)
 135
 136     file_contents = {}
 137     def DoIt():
 138       metadata = html_module.Parse(FakeLoader(["/tmp"], file_contents),
 139                                    "a.b.start",
 140                                    "/tmp/a/b/",
 141                                    parse_results)
 142     self.assertRaises(Exception, DoIt)
 143
 144   def testValidImportOfModule(self):
 145     parse_results = parse_html_deps.HTMLModuleParserResults("""<!DOCTYPE html>
 146       <link rel="import" href="../foo.html">
 147       """)
 148
 149     file_contents = {}
 150     file_contents['/tmp/a/foo.html'] = """
 151 """
 152
 153     metadata = html_module.Parse(FakeLoader(["/tmp"], file_contents),
 154                                  "a.b.start",
 155                                  "/tmp/a/b/",
 156                                  parse_results)
 157     self.assertEquals(['a.foo'], metadata.dependent_module_names)
 158
 159   def testStyleSheetImport(self):
 160     parse_results = parse_html_deps.HTMLModuleParserResults("""<!DOCTYPE html>
 161       <link rel="stylesheet" href="../foo.css">
 162       """)
 163
 164     file_contents = {}
 165     file_contents['/tmp/a/foo.css'] = """
 166 """
 167     metadata = html_module.Parse(FakeLoader(["/tmp"], file_contents),
 168                                  "a.b.start",
 169                                  "/tmp/a/b/",
 170                                  parse_results)
 171     self.assertEquals([], metadata.dependent_module_names)
 172     self.assertEquals(['a.foo'], metadata.style_sheet_names)
 173
 174   def testUsingAbsoluteHref(self):
 175     parse_results = parse_html_deps.HTMLModuleParserResults("""<!DOCTYPE html>
 176       <script src="/foo.js">
 177       """)
 178
 179     file_contents = {}
 180     file_contents['/src/foo.js'] = ''
 181
 182     metadata = html_module.Parse(FakeLoader(["/tmp", "/src"], file_contents),
 183                                  "a.b.start",
 184                                  "/tmp/a/b/",
 185                                  parse_results)
 186     self.assertEquals(['foo.js'], metadata.dependent_raw_script_relative_paths)
 187
 188
 189 class HTMLModuleTests(unittest.TestCase):
 190   def testBasic(self):
 191     file_contents = {}
 192     file_contents['/tmp/a/b/start.html'] = """
 193 <!DOCTYPE html>
 194 <link rel="import" href="/widget.html">
 195 <link rel="stylesheet" href="../common.css">
 196 <script src="/raw_script.js"></script>
 197 <polymer-element name="start">
 198   <template>
 199   </template>
 200   <script>
 201     'use strict';
 202     console.log('inline script for start.html got written');
 203   </script>
 204 </polymer-element>
 205 """
 206     file_contents['/tvcm/tvcm.html'] = """<!DOCTYPE html>
 207 """
 208     file_contents['/components/widget.html'] = """
 209 <!DOCTYPE html>
 210 <link rel="import" href="/tvcm.html">
 211 <widget name="widget.html"></widget>
 212 <script>
 213 'use strict';
 214 console.log('inline script for widget.html');
 215 </script>
 216 """
 217     file_contents['/tmp/a/common.css'] = """
 218 /* /tmp/a/common.css was written */
 219 """
 220     file_contents['/raw/raw_script.js'] = """
 221 console.log('/raw/raw_script.js was written');
 222 """
 223     file_contents['/raw/polymer.js'] = """
 224 """
 225
 226     with fake_fs.FakeFS(file_contents):
 227       project = project_module.Project(['/tvcm/', '/tmp/', '/components/', '/raw/'],
 228                                        include_tvcm_paths=False)
 229       loader = resource_loader.ResourceLoader(project)
 230       a_b_start_module = loader.LoadModule(module_name='a.b.start')
 231       load_sequence = project.CalcLoadSequenceForModules([a_b_start_module])
 232
 233       # Check load sequence names.
 234       load_sequence_names = [x.name for x in load_sequence]
 235       self.assertEquals(['tvcm',
 236                          'widget',
 237                          'a.b.start'], load_sequence_names)
 238
 239
 240       # Check module_deps on a_b_start_module
 241       def HasDependentModule(module, name):
 242         return [x for x in module.dependent_modules
 243                 if x.name == name]
 244       assert HasDependentModule(a_b_start_module, 'widget')
 245
 246       # Check JS generation.
 247       js = generate.GenerateJS(load_sequence)
 248       assert 'inline script for start.html' in js
 249       assert 'inline script for widget.html' in js
 250       assert '/raw/raw_script.js' in js
 251
 252       # Check HTML generation.
 253       html = generate.GenerateStandaloneHTMLAsString(load_sequence, title='',
 254                                                      flattened_js_url="/blah.js")
 255       assert '<polymer-element name="start">' in html
 256       assert 'inline script for widget.html' not in html
 257       assert 'common.css' in html
 258
 259   def testPolymerConversion(self):
 260     file_contents = {}
 261     file_contents['/tmp/a/b/my_component.html'] = """
 262 <!DOCTYPE html>
 263 <polymer-element name="my-component">
 264   <template>
 265   </template>
 266   <script>
 267     'use strict';
 268     Polymer ( {
 269     });
 270   </script>
 271 </polymer-element>
 272 """
 273     with fake_fs.FakeFS(file_contents):
 274       project = project_module.Project(['/tvcm/', '/tmp/'],
 275                                        include_tvcm_paths=False)
 276       loader = resource_loader.ResourceLoader(project)
 277       my_component = loader.LoadModule(module_name='a.b.my_component')
 278
 279       f = StringIO.StringIO()
 280       my_component.AppendJSContentsToFile(
 281           f,
 282           use_include_tags_for_scripts=False,
 283           dir_for_include_tag_root=None)
 284       js = f.getvalue().rstrip()
 285       expected_js = """
 286     'use strict';
 287     Polymer ( 'my-component', {
 288     });
 289 """.rstrip()
 290       self.assertEquals(expected_js, js)
 291
 292   def testPolymerConversion2(self):
 293     file_contents = {}
 294     file_contents['/tmp/a/b/my_component.html'] = """
 295 <!DOCTYPE html>
 296 <polymer-element name="my-component">
 297   <template>
 298   </template>
 299   <script>
 300     'use strict';
 301     Polymer ( );
 302   </script>
 303 </polymer-element>
 304 """
 305     with fake_fs.FakeFS(file_contents):
 306       project = project_module.Project(['/tvcm/', '/tmp/'],
 307                                        include_tvcm_paths=False)
 308       loader = resource_loader.ResourceLoader(project)
 309       my_component = loader.LoadModule(module_name='a.b.my_component')
 310
 311       f = StringIO.StringIO()
 312       my_component.AppendJSContentsToFile(
 313           f,
 314           use_include_tags_for_scripts=False,
 315           dir_for_include_tag_root=None)
 316       js = f.getvalue().rstrip()
 317       expected_js = """
 318     'use strict';
 319     Polymer ( 'my-component');
 320 """.rstrip()
 321       self.assertEquals(expected_js, js)
 322
 323
 324   def testInlineStylesheetURLs(self):
 325     file_contents = {}
 326     file_contents['/tmp/a/b/my_component.html'] = """
 327 <!DOCTYPE html>
 328 <style>
 329 .some-rule {
 330     background-image: url('../something.jpg');
 331 }
 332 </style>
 333 """
 334     file_contents['/tmp/a/something.jpg'] = 'jpgdata'
 335     with fake_fs.FakeFS(file_contents):
 336       project = project_module.Project(['/tvcm/', '/tmp/'],
 337                                        include_tvcm_paths=False)
 338       loader = resource_loader.ResourceLoader(project)
 339       my_component = loader.LoadModule(module_name='a.b.my_component')
 340
 341       computed_deps = []
 342       my_component.AppendDirectlyDependentFilenamesTo(computed_deps)
 343       self.assertEquals(set(computed_deps),
 344                         set(['/tmp/a/b/my_component.html',
 345                              '/tmp/a/something.jpg']))
 346
 347       f = StringIO.StringIO()
 348       ctl = html_generation_controller.HTMLGenerationController()
 349       my_component.AppendHTMLContentsToFile(f, ctl)
 350       html = f.getvalue().rstrip()
 351       expected_html = """
 352 .some-rule {
 353     background-image: url(data:image/jpg;base64,anBnZGF0YQ==);
 354 }
 355 """.rstrip()
 356       print html