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'))
