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