def CreateServerInstance(self): object_store_creator = ObjectStoreCreator(start_empty=False) branch_utility = self._delegate.CreateBranchUtility( object_store_creator) host_file_system_creator = self._delegate.CreateHostFileSystemCreator( object_store_creator) # offline=False because a patch can rely on files that are already in SVN # repository but not yet pulled into data store by cron jobs (a typical # example is to add documentation for an existing API). base_file_system = CachingFileSystem( host_file_system_creator.Create(offline=False), object_store_creator) base_compiled_fs_factory = CompiledFileSystem.Factory( base_file_system, object_store_creator) rietveld_patcher = CachingRietveldPatcher( RietveldPatcher( svn_constants.EXTENSIONS_PATH, self._issue, AppEngineUrlFetcher(url_constants.CODEREVIEW_SERVER)), object_store_creator) patched_file_system = PatchedFileSystem(base_file_system, rietveld_patcher) patched_compiled_fs_factory = CompiledFileSystem.Factory( patched_file_system, object_store_creator) compiled_fs_factory = ChainedCompiledFileSystem.Factory([ (patched_compiled_fs_factory, patched_file_system), (base_compiled_fs_factory, base_file_system) ]) return ServerInstance( object_store_creator, patched_file_system, self._delegate.CreateAppSamplesFileSystem(object_store_creator), '/_patch/%s' % self._issue, compiled_fs_factory, branch_utility, host_file_system_creator)
def CreateServerInstanceForChannel(self, channel): base_object_store_creator = ObjectStoreCreator(channel, start_empty=False) # TODO(fj): Use OfflineFileSystem here once all json/idl files in api/ # are pulled into data store by cron jobs. base_file_system = CachingFileSystem( self._delegate.CreateHostFileSystemForBranch(channel), base_object_store_creator) base_compiled_fs_factory = CompiledFileSystem.Factory( base_file_system, base_object_store_creator) object_store_creator = ObjectStoreCreator('trunk@%s' % self._issue, start_empty=False) rietveld_patcher = CachingRietveldPatcher( RietveldPatcher( svn_constants.EXTENSIONS_PATH, self._issue, AppEngineUrlFetcher(url_constants.CODEREVIEW_SERVER)), object_store_creator) patched_file_system = PatchedFileSystem(base_file_system, rietveld_patcher) patched_compiled_fs_factory = CompiledFileSystem.Factory( patched_file_system, object_store_creator) compiled_fs_factory = ChainedCompiledFileSystem.Factory([ (patched_compiled_fs_factory, patched_file_system), (base_compiled_fs_factory, base_file_system) ]) return ServerInstance( channel, object_store_creator, patched_file_system, self._delegate.CreateAppSamplesFileSystem( base_object_store_creator), '/_patch/%s' % self._issue, compiled_fs_factory)
def create_compiled_fs(fs, fn, category): return CompiledFileSystem.Factory( fs, object_store_creator_factory).Create(fn, SamplesDataSource, category=category, version=_VERSION)
def _create_availability_finder(self, host_fs_creator, host_fs_iterator, platform): test_object_store = ObjectStoreCreator.ForTest() return AvailabilityFinder( self._branch_utility, CompiledFileSystem.Factory(test_object_store), host_fs_iterator, host_fs_creator.GetTrunk(), test_object_store, platform)
def ForTest(file_system): object_store_creator = ObjectStoreCreator.ForTest() return ServerInstance( object_store_creator, file_system, EmptyDirFileSystem(), '', CompiledFileSystem.Factory(file_system, object_store_creator), TestBranchUtility.CreateWithCannedData(), HostFileSystemCreator.ForTest(file_system, object_store_creator))
def _CreateFactory(): return CompiledFileSystem.Factory( TestFileSystem(deepcopy(_TEST_DATA)), ObjectStoreCreator('test', start_empty=False, store_type=TestObjectStore, disable_wrappers=True))
def setUp(self): test_file_system = TestFileSystem(_FILE_SYSTEM_DATA) self._github_fs_provider = _MockGithubFileSystemProvider( test_file_system) self._content_providers = ContentProviders( CompiledFileSystem.Factory(ObjectStoreCreator.ForTest()), test_file_system, self._github_fs_provider)
def setUp(self): object_store_creator = ObjectStoreCreator(start_empty=False) base_file_system = TestFileSystem(_TEST_DATA_BASE) self._base_factory = CompiledFileSystem.Factory( base_file_system, object_store_creator) self._file_system = TestFileSystem(_TEST_DATA_NEW) self._patched_factory = CompiledFileSystem.Factory( self._file_system, object_store_creator) self._chained_factory = ChainedCompiledFileSystem.Factory([ (self._patched_factory, self._file_system), (self._base_factory, base_file_system) ]) self._base_compiled_fs = self._base_factory.Create( identity, TestFileSystem) self._chained_compiled_fs = self._chained_factory.Create( identity, TestFileSystem)
def create_availability_finder(host_fs_creator): test_object_store = ObjectStoreCreator.ForTest() return AvailabilityFinder( self._branch_utility, CompiledFileSystem.Factory(test_object_store), HostFileSystemIterator(host_fs_creator, self._branch_utility), host_fs_creator.GetTrunk(), test_object_store)
def testSimple(self): self._base_path = os.path.join(self._base_path, 'simple') fetcher = LocalFileSystem(self._base_path) compiled_fs_factory = CompiledFileSystem.Factory( fetcher, ObjectStoreCreator.Factory()) t_data_source = self._CreateTemplateDataSource( compiled_fs_factory, ObjectStoreCreator.Factory()) template_a1 = Handlebar(self._ReadLocalFile('test1.html')) self.assertEqual( template_a1.render({}, { 'templates': {} }).text, t_data_source.get('test1').render({}, { 'templates': {} }).text) template_a2 = Handlebar(self._ReadLocalFile('test2.html')) self.assertEqual( template_a2.render({}, { 'templates': {} }).text, t_data_source.get('test2').render({}, { 'templates': {} }).text) self.assertEqual(None, t_data_source.get('junk.html'))
def __init__(self, channel, object_store_creator_factory, svn_file_system, github_file_system): self.svn_file_system = svn_file_system self.github_file_system = github_file_system self.compiled_fs_factory = CompiledFileSystem.Factory( svn_file_system, object_store_creator_factory) self.api_list_data_source_factory = APIListDataSource.Factory( self.compiled_fs_factory, svn_constants.API_PATH, svn_constants.PUBLIC_TEMPLATE_PATH) self.api_data_source_factory = APIDataSource.Factory( self.compiled_fs_factory, svn_constants.API_PATH) self.ref_resolver_factory = ReferenceResolver.Factory( self.api_data_source_factory, self.api_list_data_source_factory, object_store_creator_factory) 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 you actually want to test samples, then # good luck, and modify _IsSamplesDisabled at the top. if _IsSamplesDisabled(): svn_fs_for_samples = EmptyDirFileSystem() else: svn_fs_for_samples = self.svn_file_system self.samples_data_source_factory = SamplesDataSource.Factory( channel, svn_fs_for_samples, self.github_file_system, self.ref_resolver_factory, object_store_creator_factory, svn_constants.EXAMPLES_PATH) self.api_data_source_factory.SetSamplesDataSourceFactory( self.samples_data_source_factory) self.intro_data_source_factory = IntroDataSource.Factory( self.compiled_fs_factory, self.ref_resolver_factory, [svn_constants.INTRO_PATH, svn_constants.ARTICLE_PATH]) self.sidenav_data_source_factory = SidenavDataSource.Factory( self.compiled_fs_factory, svn_constants.JSON_PATH) self.template_data_source_factory = TemplateDataSource.Factory( channel, self.api_data_source_factory, self.api_list_data_source_factory, self.intro_data_source_factory, self.samples_data_source_factory, self.sidenav_data_source_factory, self.compiled_fs_factory, self.ref_resolver_factory, svn_constants.PUBLIC_TEMPLATE_PATH, svn_constants.PRIVATE_TEMPLATE_PATH) self.example_zipper = ExampleZipper(self.compiled_fs_factory, svn_constants.DOCS_PATH) self.path_canonicalizer = PathCanonicalizer(channel, self.compiled_fs_factory) self.content_cache = self.compiled_fs_factory.GetOrCreateIdentity()
def setUp(self): object_store_creator = ObjectStoreCreator.ForTest() self._file_system = CachingFileSystem( LocalFileSystem(os.path.join(sys.path[0], 'test_data')), object_store_creator) self._example_zipper = ExampleZipper( CompiledFileSystem.Factory(self._file_system, object_store_creator), 'example_zipper')
def testNotFound(self): self._base_path = os.path.join(self._base_path, 'simple') fetcher = LocalFileSystem(self._base_path) compiled_fs_factory = CompiledFileSystem.Factory( fetcher, ObjectStoreCreator.TestFactory()) t_data_source = self._CreateTemplateDataSource( compiled_fs_factory, ObjectStoreCreator.TestFactory()) self.assertEqual(None, t_data_source.get('junk.html'))
def ForTest(file_system, base_path='/'): object_store_creator = ObjectStoreCreator.ForTest() return ServerInstance(object_store_creator, CompiledFileSystem.Factory(object_store_creator), TestBranchUtility.CreateWithCannedData(), HostFileSystemProvider.ForTest( file_system, object_store_creator), GithubFileSystemProvider.ForEmpty(), base_path=base_path)
def setUp(self): object_store_creator = ObjectStoreCreator.ForTest() compiled_fs_factory = CompiledFileSystem.Factory(object_store_creator) self._mock_file_system = MockFileSystem(TestFileSystem(_TEST_DATA)) features_bundle = FeaturesBundle(self._mock_file_system, compiled_fs_factory, object_store_creator) self._api_models = APIModels(features_bundle, compiled_fs_factory, self._mock_file_system)
def setUp(self): self._base_path = os.path.join(sys.path[0], 'test_data', 'test_json') self._compiled_fs_factory = CompiledFileSystem.Factory( TestFileSystem(CANNED_TEST_FILE_SYSTEM_DATA), ObjectStoreCreator.ForTest()) self._json_cache = self._compiled_fs_factory.Create( lambda _, json: json_parse.Parse(json), APIDataSourceTest, 'test')
def setUp(self): object_store = InMemoryObjectStore('') self._file_system = MemcacheFileSystem( LocalFileSystem(os.path.join(sys.path[0], 'test_data')), object_store) self._example_zipper = ExampleZipper( self._file_system, CompiledFileSystem.Factory(self._file_system, object_store), 'example_zipper')
def _CreateContentProvider(self, supports_zip=False): test_file_system = TestFileSystem(_TEST_DATA) return ContentProvider( 'foo', CompiledFileSystem.Factory(ObjectStoreCreator.ForTest()), test_file_system, # TODO(kalman): Test supports_templates=False. supports_templates=True, supports_zip=supports_zip)
def create_availability_finder(file_system_data): fake_host_fs_creator = FakeHostFileSystemProvider(file_system_data) test_object_store = ObjectStoreCreator.ForTest() return AvailabilityFinder( self._branch_utility, CompiledFileSystem.Factory(test_object_store), HostFileSystemIterator(fake_host_fs_creator, self._branch_utility), fake_host_fs_creator.GetTrunk(), test_object_store)
def _GetTestCompiledFsCreator(): '''Returns a function which creates CompiledFileSystem views of TestFileSystems backed by _TEST_DATA. ''' return functools.partial( CompiledFileSystem.Factory( ObjectStoreCreator(start_empty=False, store_type=TestObjectStore, disable_wrappers=True), ).Create, TestFileSystem(deepcopy(_TEST_DATA)))
def ForLocal(): channel = 'trunk' object_store_creator = ObjectStoreCreator(channel, start_empty=False, store_type=TestObjectStore) file_system = CachingFileSystem(LocalFileSystem.Create(), object_store_creator) return ServerInstance( channel, object_store_creator, file_system, EmptyDirFileSystem(), '', CompiledFileSystem.Factory(file_system, object_store_creator))
def testPartials(self): self._base_path = os.path.join(self._base_path, 'partials') fetcher = LocalFileSystem(self._base_path) cache_factory = CompiledFileSystem.Factory(fetcher, self._object_store) t_data_source = self._CreateTemplateDataSource(cache_factory) self.assertEqual( self._ReadLocalFile('test_expected.html'), t_data_source.get('test_tmpl').render( json.loads(self._ReadLocalFile('input.json')), t_data_source).text)
def ForLocal(): object_store_creator = ObjectStoreCreator(start_empty=False, store_type=TestObjectStore) host_file_system_provider = HostFileSystemProvider.ForLocal( object_store_creator) return ServerInstance(object_store_creator, CompiledFileSystem.Factory(object_store_creator), TestBranchUtility.CreateWithCannedData(), host_file_system_provider, GithubFileSystemProvider.ForEmpty())
def Create(self, file_system, populate_function, cls, category=None): return ChainedCompiledFileSystem( # Chain of CompiledFileSystem instances. tuple( CompiledFileSystem.Factory(self._object_store).Create( fs, populate_function, cls, category=category) for fs in [file_system] + self._file_system_chain), # Identity, as computed by all file systems. StringIdentity(*(fs.GetIdentity() for fs in self._file_system_chain)))
def setUp(self): object_store_creator = ObjectStoreCreator(start_empty=False) base_file_system = TestFileSystem(_TEST_DATA_BASE, identity='base') self._base_compiled_fs = CompiledFileSystem.Factory( object_store_creator).Create(base_file_system, identity, ChainedCompiledFileSystemTest) chained_factory = ChainedCompiledFileSystem.Factory( [base_file_system], object_store_creator) self._new_file_system = TestFileSystem(_TEST_DATA_NEW, identity='new') self._chained_compiled_fs = chained_factory.Create( self._new_file_system, identity, ChainedCompiledFileSystemTest)
def _CreateContentProvider(self, supports_zip=False): object_store_creator = ObjectStoreCreator.ForTest() return ContentProvider( 'foo', CompiledFileSystem.Factory(object_store_creator), self._test_file_system, object_store_creator, default_extensions=('.html', '.md'), # TODO(kalman): Test supports_templates=False. supports_templates=True, supports_zip=supports_zip)
def _GetInstanceForBranch(channel_name, local_path): branch = BRANCH_UTILITY.GetBranchNumberForChannelName(channel_name) # The key for the server is a tuple of |channel_name| with |branch|, since # sometimes stable and beta point to the same branch. instance_key = _MakeInstanceKey(channel_name, branch) instance = SERVER_INSTANCES.get(instance_key, None) if instance is not None: return instance branch_memcache = InMemoryObjectStore(branch) if branch == 'local': file_system = LocalFileSystem(local_path) else: file_system = _CreateMemcacheFileSystem(branch, branch_memcache) cache_factory = CompiledFileSystem.Factory(file_system, branch_memcache) api_list_data_source_factory = APIListDataSource.Factory(cache_factory, file_system, API_PATH, PUBLIC_TEMPLATE_PATH) intro_data_source_factory = IntroDataSource.Factory( cache_factory, [INTRO_PATH, ARTICLE_PATH]) samples_data_source_factory = SamplesDataSource.Factory( channel_name, file_system, GITHUB_FILE_SYSTEM, cache_factory, GITHUB_COMPILED_FILE_SYSTEM, api_list_data_source_factory, EXAMPLES_PATH) api_data_source_factory = APIDataSource.Factory(cache_factory, API_PATH, samples_data_source_factory) template_data_source_factory = TemplateDataSource.Factory( channel_name, api_data_source_factory, api_list_data_source_factory, intro_data_source_factory, samples_data_source_factory, KNOWN_ISSUES_DATA_SOURCE, cache_factory, PUBLIC_TEMPLATE_PATH, PRIVATE_TEMPLATE_PATH) example_zipper = ExampleZipper(file_system, cache_factory, DOCS_PATH) instance = ServerInstance(template_data_source_factory, example_zipper, cache_factory) SERVER_INSTANCES[instance_key] = instance return instance
def ForLocal(): object_store_creator = ObjectStoreCreator(start_empty=False, store_type=TestObjectStore) host_file_system_creator = HostFileSystemCreator.ForLocal( object_store_creator) trunk_file_system = host_file_system_creator.Create() return ServerInstance( object_store_creator, trunk_file_system, EmptyDirFileSystem(), '', CompiledFileSystem.Factory(trunk_file_system, object_store_creator), TestBranchUtility.CreateWithCannedData(), host_file_system_creator)
def ForLocal(): object_store_creator = ObjectStoreCreator(start_empty=False, store_type=TestObjectStore) host_file_system_provider = HostFileSystemProvider.ForLocal( object_store_creator) return ServerInstance( object_store_creator, CompiledFileSystem.Factory(object_store_creator), BranchUtility.Create(object_store_creator), host_file_system_provider, CloudStorageFileSystemProvider(object_store_creator))
def testCreateManifestData(self): expected_extensions = { 'required': [{ 'name': 'req0', 'example': 'Extension' }, { 'name': 'req1' }], 'recommended': [{ 'name': 'rec0' }, { 'name': 'rec1' }], 'only_one': [{ 'name': 'only0' }], 'optional': [{ 'name': 'free1' }, { 'name': 'opt0', 'is_last': True }] } expected_apps = { 'required': [{ 'name': 'req0', 'example': 'Application' }, { 'name': 'req1' }], 'recommended': [{ 'name': 'rec1' }], 'only_one': [{ 'name': 'only0' }, { 'name': 'only1' }], 'optional': [{ 'name': 'free0' }, { 'name': 'free1', 'is_last': True }] } mds = ManifestDataSource( CompiledFileSystem.Factory(file_system, ObjectStoreCreator.ForTest()), file_system, 'manifest.json', '_manifest_features.json') self.assertEqual(expected_extensions, mds.get('extensions')) self.assertEqual(expected_apps, mds.get('apps'))