class DocumentRendererUnittest(unittest.TestCase):
    def setUp(self):
        self._renderer = DocumentRenderer(
            _FakeTableOfContentsRenderer('t-o-c'))

    def testNothingToSubstitute(self):
        document = 'hello world'

        text, warnings = self._renderer.Render(document)
        self.assertEqual(document, text)
        self.assertEqual([], warnings)

        text, warnings = self._renderer.Render(document, render_title=True)
        self.assertEqual(document, text)
        self.assertEqual(['Expected a title'], warnings)

    def testTitles(self):
        document = '<h1>title</h1> then $(title) then another $(title)'

        text, warnings = self._renderer.Render(document)
        self.assertEqual(document, text)
        self.assertEqual(['Found unexpected title "title"'], warnings)

        text, warnings = self._renderer.Render(document, render_title=True)
        self.assertEqual('<h1>title</h1> then title then another $(title)',
                         text)
        self.assertEqual([], warnings)

    def testTocs(self):
        document = ('here is a toc $(table_of_contents) '
                    'and another $(table_of_contents)')
        expected_document = 'here is a toc t-o-c and another $(table_of_contents)'

        text, warnings = self._renderer.Render(document)
        self.assertEqual(expected_document, text)
        self.assertEqual([], warnings)

        text, warnings = self._renderer.Render(document, render_title=True)
        self.assertEqual(expected_document, text)
        self.assertEqual(['Expected a title'], warnings)

    def testTitleAndToc(self):
        document = '<h1>title</h1> $(title) and $(table_of_contents)'

        text, warnings = self._renderer.Render(document)
        self.assertEqual('<h1>title</h1> $(title) and t-o-c', text)
        self.assertEqual(['Found unexpected title "title"'], warnings)

        text, warnings = self._renderer.Render(document, render_title=True)
        self.assertEqual('<h1>title</h1> title and t-o-c', text)
        self.assertEqual([], warnings)
  def __init__(self,
               object_store_creator,
               compiled_fs_factory,
               branch_utility,
               host_file_system_provider,
               github_file_system_provider,
               gcs_file_system_provider,
               base_path='/'):
    '''
    |object_store_creator|
        The ObjectStoreCreator used to create almost all caches.
    |compiled_fs_factory|
        Factory used to create CompiledFileSystems, a higher-level cache type
        than ObjectStores. This can usually be derived from just
        |object_store_creator| but under special circumstances a different
        implementation needs to be passed in.
    |branch_utility|
        Has knowledge of Chrome branches, channels, and versions.
    |host_file_system_provider|
        Creates FileSystem instances which host the server at alternative
        revisions.
    |github_file_system_provider|
        Creates FileSystem instances backed by GitHub.
    |base_path|
        The path which all HTML is generated relative to. Usually this is /
        but some servlets need to override this.
    '''
    self.object_store_creator = object_store_creator

    self.compiled_fs_factory = compiled_fs_factory

    self.host_file_system_provider = host_file_system_provider
    host_fs_at_trunk = host_file_system_provider.GetTrunk()

    self.github_file_system_provider = github_file_system_provider
    self.gcs_file_system_provider = gcs_file_system_provider

    assert base_path.startswith('/') and base_path.endswith('/')
    self.base_path = base_path

    self.host_file_system_iterator = HostFileSystemIterator(
        host_file_system_provider,
        branch_utility)

    self.features_bundle = FeaturesBundle(
        host_fs_at_trunk,
        self.compiled_fs_factory,
        self.object_store_creator)

    self.api_models = APIModels(
        self.features_bundle,
        self.compiled_fs_factory,
        host_fs_at_trunk)

    self.availability_finder = AvailabilityFinder(
        branch_utility,
        compiled_fs_factory,
        self.host_file_system_iterator,
        host_fs_at_trunk,
        object_store_creator)

    self.api_categorizer = APICategorizer(
        host_fs_at_trunk,
        compiled_fs_factory)

    self.api_data_source_factory = APIDataSource.Factory(
        self.compiled_fs_factory,
        host_fs_at_trunk,
        self.availability_finder,
        self.api_models,
        self.features_bundle,
        self.object_store_creator)

    self.ref_resolver_factory = ReferenceResolver.Factory(
        self.api_data_source_factory,
        self.api_models,
        object_store_creator)

    self.api_data_source_factory.SetReferenceResolverFactory(
        self.ref_resolver_factory)

    # Note: samples are super slow in the dev server because it doesn't support
    # async fetch, so disable them.
    if IsDevServer():
      extension_samples_fs = EmptyDirFileSystem()
      app_samples_fs = EmptyDirFileSystem()
    else:
      extension_samples_fs = host_fs_at_trunk
      # TODO(kalman): Re-enable the apps samples, see http://crbug.com/344097.
      app_samples_fs = EmptyDirFileSystem()
      #app_samples_fs = github_file_system_provider.Create(
      #    'GoogleChrome', 'chrome-app-samples')
    self.samples_data_source_factory = SamplesDataSource.Factory(
        extension_samples_fs,
        app_samples_fs,
        CompiledFileSystem.Factory(object_store_creator),
        self.ref_resolver_factory,
        base_path)

    self.api_data_source_factory.SetSamplesDataSourceFactory(
        self.samples_data_source_factory)

    self.content_providers = ContentProviders(
        object_store_creator,
        self.compiled_fs_factory,
        host_fs_at_trunk,
        self.github_file_system_provider,
        self.gcs_file_system_provider)

    # TODO(kalman): Move all the remaining DataSources into DataSourceRegistry,
    # then factor out the DataSource creation into a factory method, so that
    # the entire ServerInstance doesn't need to be passed in here.
    self.template_renderer = TemplateRenderer(self)

    # TODO(kalman): It may be better for |document_renderer| to construct a
    # TemplateDataSource itself rather than depending on template_renderer, but
    # for that the above todo should be addressed.
    self.document_renderer = DocumentRenderer(
        TableOfContentsRenderer(host_fs_at_trunk,
                                compiled_fs_factory,
                                self.template_renderer),
        self.ref_resolver_factory.Create())
    def __init__(self,
                 object_store_creator,
                 compiled_fs_factory,
                 branch_utility,
                 host_file_system_provider,
                 gcs_file_system_provider,
                 base_path='/'):
        '''
    |object_store_creator|
        The ObjectStoreCreator used to create almost all caches.
    |compiled_fs_factory|
        Factory used to create CompiledFileSystems, a higher-level cache type
        than ObjectStores. This can usually be derived from just
        |object_store_creator| but under special circumstances a different
        implementation needs to be passed in.
    |branch_utility|
        Has knowledge of Chrome branches, channels, and versions.
    |host_file_system_provider|
        Creates FileSystem instances which host the server at alternative
        revisions.
    |base_path|
        The path which all HTML is generated relative to. Usually this is /
        but some servlets need to override this.
    '''
        self.object_store_creator = object_store_creator

        self.compiled_fs_factory = compiled_fs_factory

        self.host_file_system_provider = host_file_system_provider
        host_fs_at_master = host_file_system_provider.GetMaster()

        self.gcs_file_system_provider = gcs_file_system_provider

        assert base_path.startswith('/') and base_path.endswith('/')
        self.base_path = base_path

        self.host_file_system_iterator = HostFileSystemIterator(
            host_file_system_provider, branch_utility)

        self.platform_bundle = PlatformBundle(branch_utility,
                                              self.compiled_fs_factory,
                                              host_fs_at_master,
                                              self.host_file_system_iterator,
                                              self.object_store_creator,
                                              self.base_path)

        self.content_providers = ContentProviders(
            object_store_creator, self.compiled_fs_factory, host_fs_at_master,
            self.gcs_file_system_provider)

        # TODO(kalman): Move all the remaining DataSources into DataSourceRegistry,
        # then factor out the DataSource creation into a factory method, so that
        # the entire ServerInstance doesn't need to be passed in here.
        self.template_renderer = TemplateRenderer(self)

        # TODO(kalman): It may be better for |document_renderer| to construct a
        # TemplateDataSource itself rather than depending on template_renderer, but
        # for that the above todo should be addressed.
        self.document_renderer = DocumentRenderer(
            TableOfContentsRenderer(host_fs_at_master, compiled_fs_factory,
                                    self.template_renderer),
            self.platform_bundle)
 def setUp(self):
     self._renderer = DocumentRenderer(
         _FakeTableOfContentsRenderer('t-o-c'))