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.ForTest())
t_data_source = self._CreateTemplateDataSource(
compiled_fs_factory,
ObjectStoreCreator.ForTest())
self.assertEqual(None, t_data_source.get('junk.html'))
def setUp(self):
self._avail_ds_factory = AvailabilityFinder.Factory(
ObjectStoreCreator.ForTest(),
CompiledFileSystem.Factory(
TestFileSystem(CANNED_API_FILE_SYSTEM_DATA['trunk']),
ObjectStoreCreator.ForTest()),
BranchUtility(
os.path.join('branch_utility', 'first.json'),
os.path.join('branch_utility', 'second.json'),
FakeUrlFetcher(os.path.join(sys.path[0], 'test_data')),
ObjectStoreCreator.ForTest()), _CreateCannedFileSystem)
self._avail_ds = self._avail_ds_factory.Create()
def setUp(self):
object_store_creator = ObjectStoreCreator.ForTest()
test_file_system = TestFileSystem(_FILE_SYSTEM_DATA,
relative_to=CHROME_EXTENSIONS)
object_store_creator = ObjectStoreCreator.ForTest()
# TODO(mangini): create tests for GCS
self._gcs_fs_provider = CloudStorageFileSystemProvider(object_store_creator)
self._content_providers = ContentProviders(
object_store_creator,
CompiledFileSystem.Factory(object_store_creator),
test_file_system,
self._gcs_fs_provider)
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 setUp(self):
ConfigureFakeFetchers()
self._base_path = os.path.join(sys.path[0], 'test_data',
'github_file_system')
self._file_system = GithubFileSystem(
AppEngineUrlFetcher(url_constants.GITHUB_URL),
AppEngineBlobstore(), ObjectStoreCreator.ForTest())
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 _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 testSimple(self):
self._base_path = os.path.join(self._base_path, 'simple')
fetcher = LocalFileSystem(self._base_path)
compiled_fs_factory = CompiledFileSystem.Factory(
fetcher,
ObjectStoreCreator.ForTest())
t_data_source = self._CreateTemplateDataSource(
compiled_fs_factory,
ObjectStoreCreator.ForTest())
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)
def setUp(self):
self._branch_utility = BranchUtility(
os.path.join('branch_utility', 'first.json'),
os.path.join('branch_utility', 'second.json'),
FakeUrlFetcher(Server2Path('test_data')),
ObjectStoreCreator.ForTest())
self._api_fs_creator = FakeHostFileSystemProvider(
CANNED_API_FILE_SYSTEM_DATA)
self._node_fs_creator = FakeHostFileSystemProvider(
TABS_SCHEMA_BRANCHES)
self._api_fs_iterator = HostFileSystemIterator(self._api_fs_creator,
self._branch_utility)
self._node_fs_iterator = HostFileSystemIterator(
self._node_fs_creator, self._branch_utility)
# Imitate the actual SVN file system by incrementing the stats for paths
# where an API schema has changed.
last_stat = type('last_stat', (object, ), {'val': 0})
def stat_paths(file_system, channel_info):
if channel_info.version not in TABS_UNMODIFIED_VERSIONS:
last_stat.val += 1
# HACK: |file_system| is a MockFileSystem backed by a TestFileSystem.
# Increment the TestFileSystem stat count.
file_system._file_system.IncrementStat(by=last_stat.val)
# Continue looping. The iterator will stop after 'trunk' automatically.
return True
# Use the HostFileSystemIterator created above to change global stat values
# for the TestFileSystems that it creates.
self._node_fs_iterator.Ascending(
# The earliest version represented with the tabs' test data is 13.
self._branch_utility.GetStableChannelInfo(13),
stat_paths)
def _CreateTemplateDataSource(self, compiled_fs_factory, api_data=None):
if api_data is None:
api_data_factory = APIDataSource.Factory(compiled_fs_factory,
'fake_path',
_FakeFactory())
else:
api_data_factory = _FakeFactory(api_data)
reference_resolver_factory = ReferenceResolver.Factory(
api_data_factory,
self._fake_api_list_data_source_factory,
ObjectStoreCreator.ForTest())
@DisableLogging('error') # "was never set" error
def create_from_factory(factory):
path = 'extensions/foo'
return factory.Create(Request.ForTest(path), path)
return create_from_factory(TemplateDataSource.Factory(
api_data_factory,
self._fake_api_list_data_source_factory,
self._fake_intro_data_source_factory,
self._fake_samples_data_source_factory,
self._fake_sidenav_data_source_factory,
compiled_fs_factory,
reference_resolver_factory,
self._manifest_data_source,
'.',
'.',
''))
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 setUp(self):
tabs_unmodified_versions = (16, 20, 23, 24)
self._branch_utility = BranchUtility(
os.path.join('branch_utility', 'first.json'),
os.path.join('branch_utility', 'second.json'),
FakeUrlFetcher(Server2Path('test_data')),
ObjectStoreCreator.ForTest())
self._node_fs_creator = FakeHostFileSystemProvider(TABS_SCHEMA_BRANCHES)
self._node_fs_iterator = HostFileSystemIterator(self._node_fs_creator,
self._branch_utility)
test_object_store = ObjectStoreCreator.ForTest()
self._avail_finder = AvailabilityFinder(
self._branch_utility,
CompiledFileSystem.Factory(test_object_store),
self._node_fs_iterator,
self._node_fs_creator.GetMaster(),
test_object_store,
'extensions',
SchemaProcessorFactoryForTest())
server_instance = ServerInstance.ForTest(
file_system_provider=FakeHostFileSystemProvider(
TABS_SCHEMA_BRANCHES))
self._api_models = server_instance.platform_bundle.GetAPIModels(
'extensions')
self._json_cache = server_instance.compiled_fs_factory.ForJson(
server_instance.host_file_system_provider.GetMaster())
# Imitate the actual SVN file system by incrementing the stats for paths
# where an API schema has changed.
last_stat = type('last_stat', (object,), {'val': 0})
def stat_paths(file_system, channel_info):
if channel_info.version not in tabs_unmodified_versions:
last_stat.val += 1
# HACK: |file_system| is a MockFileSystem backed by a TestFileSystem.
# Increment the TestFileSystem stat count.
file_system._file_system.IncrementStat(by=last_stat.val)
# Continue looping. The iterator will stop after 'master' automatically.
return True
# Use the HostFileSystemIterator created above to change global stat values
# for the TestFileSystems that it creates.
self._node_fs_iterator.Ascending(
# The earliest version represented with the tabs' test data is 13.
self._branch_utility.GetStableChannelInfo(13),
stat_paths)
def testWithOffline(self):
creator = HostFileSystemCreator(ObjectStoreCreator.ForTest(),
offline=True,
constructor_for_test=ConstructorForTest)
fs = creator.Create('trunk')
# Offline file system should raise a FileNotFoundError if read is attempted.
self.assertRaises(FileNotFoundError, fs.ReadSingle, self._idle_path)
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 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 ForTest(repo, fake_fetcher, path=None, object_store_creator=None):
'''Creates a GithubFileSystem that can be used for testing. It reads zip
files and commit data from server2/test_data/github_file_system/test_owner
instead of github.com. It reads from files specified by |repo|.
'''
return GithubFileSystem(
path if path is not None else 'test_data/github_file_system',
'test_owner', repo, object_store_creator
or ObjectStoreCreator.ForTest(), fake_fetcher)
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 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_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 _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 testWithOffline(self):
creator = HostFileSystemProvider(
ObjectStoreCreator.ForTest(),
offline=True,
constructor_for_test=self._constructor_for_test)
fs = creator.GetBranch('1500')
# Offline file system should raise a FileNotFoundError if read is attempted.
self.assertRaises(FileNotFoundError, fs.ReadSingle(self._idle_path).Get)
def testWithCaching(self):
creator = HostFileSystemCreator(ObjectStoreCreator.ForTest(),
constructor_for_test=ConstructorForTest)
fs = creator.Create('trunk')
firstRead = fs.ReadSingle(self._idle_path)
CANNED_API_FILE_SYSTEM_DATA['trunk']['api']['idle.json'] = 'blah blah blah'
secondRead = fs.ReadSingle(self._idle_path)
self.assertEqual(firstRead, secondRead)
def testWithCaching(self):
creator = HostFileSystemProvider(
ObjectStoreCreator.ForTest(),
constructor_for_test=self._constructor_for_test)
fs = creator.GetBranch('1500')
first_read = fs.ReadSingle(self._idle_path).Get()
self._canned_data['1500']['api']['idle.json'] = 'blah blah blah'
second_read = fs.ReadSingle(self._idle_path).Get()
self.assertEqual(first_read, second_read)
def setUp(self):
def host_file_system_constructor(branch, **optargs):
return TestFileSystem(deepcopy(
CANNED_API_FILE_SYSTEM_DATA[branch]))
host_file_system_provider = HostFileSystemProvider(
ObjectStoreCreator.ForTest(),
constructor_for_test=host_file_system_constructor)
self._branch_utility = TestBranchUtility.CreateWithCannedData()
self._iterator = HostFileSystemIterator(host_file_system_provider,
self._branch_utility)
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 testPartials(self):
self._base_path = os.path.join(self._base_path, 'partials')
fetcher = LocalFileSystem(self._base_path)
compiled_fs_factory = CompiledFileSystem.Factory(
fetcher,
ObjectStoreCreator.ForTest())
t_data_source = self._CreateTemplateDataSource(compiled_fs_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 setUp(self):
object_store_creator = ObjectStoreCreator.ForTest()
compiled_fs_factory = CompiledFileSystem.Factory(object_store_creator)
self._mock_file_system = MockFileSystem(
TestFileSystem(_TEST_DATA, relative_to=CHROME_EXTENSIONS))
features_bundle = FeaturesBundle(self._mock_file_system,
compiled_fs_factory,
object_store_creator, 'extensions')
self._api_models = APIModels(features_bundle, compiled_fs_factory,
self._mock_file_system,
object_store_creator, 'extensions')
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'))
def testCorrectFutureBehaviour(self):
# Tests that the underlying FileSystem's Read Future has had Get() called
# on it before the Future is resolved, but the underlying Future isn't
# resolved until Get is.
mock_fs = MockFileSystem(TestFileSystem(_TEST_DATA))
compiled_fs = CompiledFileSystem.Factory(
ObjectStoreCreator.ForTest()).Create(
mock_fs, lambda path, contents: contents, type(self))
self.assertTrue(*mock_fs.CheckAndReset())
future = compiled_fs.GetFromFile('404.html')
self.assertTrue(*mock_fs.CheckAndReset(stat_count=1, read_count=1))
future.Get()
self.assertTrue(*mock_fs.CheckAndReset(read_resolve_count=1))
future = compiled_fs.GetFromFileListing('apps/')
# Current behaviour is to have read=2 and read_resolve=1 because the first
# level is read eagerly, then all of the second is read (in parallel). If
# it weren't eager (and it may be worth experimenting with that) then it'd
# be read=1 and read_resolve=0.
self.assertTrue(*mock_fs.CheckAndReset(stat_count=1,
read_count=2,
read_resolve_count=1))
future.Get()
# It's doing 1 more level 'deeper' (already read 'fakedir' and 'deepdir'
# though not resolved), so that's 1 more read/resolve + the resolve from
# the first read.
self.assertTrue(*mock_fs.CheckAndReset(read_count=1, read_resolve_count=2))
# Even though the directory is 1 layer deep the caller has no way of
# determining that ahead of time (though perhaps the API could give some
# kind of clue, if we really cared).
future = compiled_fs.GetFromFileListing('extensions/')
self.assertTrue(*mock_fs.CheckAndReset(stat_count=1,
read_count=1,
read_resolve_count=1))
future.Get()
self.assertTrue(*mock_fs.CheckAndReset())
# Similar configuration to the 'apps/' case but deeper.
future = compiled_fs.GetFromFileListing('')
self.assertTrue(*mock_fs.CheckAndReset(stat_count=1,
read_count=2,
read_resolve_count=1))
future.Get()
self.assertTrue(*mock_fs.CheckAndReset(read_count=2, read_resolve_count=3))
def testRender(self):
self._base_path = os.path.join(self._base_path, 'render')
fetcher = LocalFileSystem(self._base_path)
context = json.loads(self._ReadLocalFile('test1.json'))
compiled_fs_factory = CompiledFileSystem.Factory(
fetcher,
ObjectStoreCreator.ForTest())
self._RenderTest(
'test1',
self._CreateTemplateDataSource(
compiled_fs_factory,
api_data=json.loads(self._ReadLocalFile('test1.json'))))
self._RenderTest(
'test2',
self._CreateTemplateDataSource(
compiled_fs_factory,
api_data=json.loads(self._ReadLocalFile('test2.json'))))