rhodecode-vcsserver Commit - r964:1fc3584c

caches: small naming refactor to fix tests.

super-admin -

r964:1fc3584c default

parent child

vcsserver/git.py

0 +21 -21

                 @reraise_safe_exceptions
                 def assert_correct_path(self, wire):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _assert_correct_path(_context_uid, _repo_id):
                         try:
                 @reraise_safe_exceptions
                 def blob_raw_length(self, wire, sha):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _blob_raw_length(_repo_id, _sha):
                 def is_large_file(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _is_large_file(_repo_id, _sha):
                         repo_init = self._factory.repo_libgit2(wire)
                 def is_binary(self, wire, tree_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _is_binary(_repo_id, _tree_id):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def bulk_request(self, wire, rev, pre_load):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _bulk_request(_repo_id, _rev, _pre_load):
                         result = {}
                 @reraise_safe_exceptions
                 def branch(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _branch(_context_uid, _repo_id, _commit_id):
                         regex = re.compile('^refs/heads')
                 @reraise_safe_exceptions
                 def commit_branches(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _commit_branches(_context_uid, _repo_id, _commit_id):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def get_object(self, wire, sha, maybe_unreachable=False):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_object(_context_uid, _repo_id, _sha):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def get_refs(self, wire):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_refs(_context_uid, _repo_id):
                 @reraise_safe_exceptions
                 def get_branch_pointers(self, wire):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_branch_pointers(_context_uid, _repo_id):
                 @reraise_safe_exceptions
                 def head(self, wire, show_exc=True):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _head(_context_uid, _repo_id, _show_exc):
                         repo_init = self._factory.repo_libgit2(wire)
                 def revision(self, wire, rev):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _revision(_context_uid, _repo_id, _rev):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def date(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _date(_repo_id, _commit_id):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def author(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _author(_repo_id, _commit_id):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def message(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _message(_repo_id, _commit_id):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def parents(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _parents(_repo_id, _commit_id):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def children(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _children(_repo_id, _commit_id):
                         output, __ = self.run_git_command(
                 def tree_and_type_for_path(self, wire, commit_id, path):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _tree_and_type_for_path(_context_uid, _repo_id, _commit_id, _path):
                         repo_init = self._factory.repo_libgit2(wire)
                 @reraise_safe_exceptions
                 def tree_items(self, wire, tree_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _tree_items(_repo_id, _tree_id):
                 @reraise_safe_exceptions
                 def node_history(self, wire, commit_id, path, limit):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _node_history(_context_uid, _repo_id, _commit_id, _path, _limit):
                         # optimize for n==1, rev-list is much faster for that use-case
                 def get_all_commit_ids(self, wire):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_all_commit_ids(_context_uid, _repo_id):

vcsserver/hg.py

0 +21 -21

                 @reraise_safe_exceptions
                 def bookmarks(self, wire):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _bookmarks(_context_uid, _repo_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def branches(self, wire, normal, closed):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _branches(_context_uid, _repo_id, _normal, _closed):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def bulk_request(self, wire, commit_id, pre_load):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _bulk_request(_repo_id, _commit_id, _pre_load):
                         result = {}
                 @reraise_safe_exceptions
                 def ctx_branch(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_branch(_repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def ctx_date(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_date(_repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def ctx_files(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_files(_repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def ctx_parents(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_parents(_repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def ctx_children(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_children(_repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def ctx_phase(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_phase(_context_uid, _repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def ctx_obsolete(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_obsolete(_context_uid, _repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def ctx_hidden(self, wire, commit_id):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _ctx_hidden(_context_uid, _repo_id, _commit_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def node_history(self, wire, revision, path, limit):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _node_history(_context_uid, _repo_id, _revision, _path, _limit):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def node_history_untill(self, wire, revision, path, limit):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _node_history_until(_context_uid, _repo_id):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def fctx_flags(self, wire, commit_id, path):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _fctx_flags(_repo_id, _commit_id, _path):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def fctx_size(self, wire, commit_id, path):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _fctx_size(_repo_id, _revision, _path):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def get_all_commit_ids(self, wire, name):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_all_commit_ids(_context_uid, _repo_id, _name):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def is_large_file(self, wire, commit_id, path):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _is_large_file(_context_uid, _repo_id, _commit_id, _path):
                         return largefiles.lfutil.isstandin(path)
                 def is_binary(self, wire, revision, path):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _is_binary(_repo_id, _sha, _path):
                         repo = self._factory.repo(wire)
                 def lookup(self, wire, revision, both):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _lookup(_context_uid, _repo_id, _revision, _both):
                 def rev_range(self, wire, commit_filter):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _rev_range(_context_uid, _repo_id, _filter):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def tags(self, wire):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _tags(_context_uid, _repo_id):
                         repo = self._factory.repo(wire)

vcsserver/svn.py

0 +7 -7

                 def revision_properties(self, wire, revision):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _revision_properties(_repo_id, _revision):
                         repo = self._factory.repo(wire)
                 @reraise_safe_exceptions
                 def node_history(self, wire, path, revision, limit):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _assert_correct_path(_context_uid, _repo_id, _path, _revision, _limit):
                         cross_copies = False
                 def node_properties(self, wire, path, revision):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _node_properties(_repo_id, _path, _revision):
                         repo = self._factory.repo(wire)
                 def get_node_type(self, wire, path, revision=None):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_node_type(_repo_id, _path, _revision):
                         repo = self._factory.repo(wire)
                 def get_nodes(self, wire, path, revision=None):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_nodes(_repo_id, _path, _revision):
                         repo = self._factory.repo(wire)
                 def get_file_size(self, wire, path, revision=None):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _get_file_size(_repo_id, _path, _revision):
                         repo = self._factory.repo(wire)
                 def is_binary(self, wire, rev, path):
                     cache_on, context_uid, repo_id = self._cache_on(wire)
-                    region = self.region(wire)
+                    region = self._region(wire)
                     @region.conditional_cache_on_arguments(condition=cache_on)
                     def _is_binary(_repo_id, _rev, _path):
                         raw_bytes = self.get_file_content(wire, path, rev)

vcsserver/tests/test_git.py

0 +1 -1

                     methods = inspect.getmembers(git_remote, predicate=inspect.ismethod)
                     for method_name, method in methods:
-                        if not method_name.startswith('_'):
+                        if not method_name.startswith('_') and method_name not in ['vcsserver_invalidate_cache']:
                             assert method.im_func.__code__ == decorator.__code__
                 @pytest.mark.parametrize('side_effect, expected_type', [

vcsserver/tests/test_hg.py

0 +1 -1

                     methods = inspect.getmembers(hg_remote, predicate=inspect.ismethod)
                     decorator = hg.reraise_safe_exceptions(None)
                     for method_name, method in methods:
-                        if not method_name.startswith('_'):
+                        if not method_name.startswith('_') and method_name not in ['vcsserver_invalidate_cache']:
                             assert method.im_func.__code__ == decorator.__code__
                 @pytest.mark.parametrize('side_effect, expected_type', [

vcsserver/vcs_base.py

0 +1 -1

             class RemoteBase(object):
                 EMPTY_COMMIT = '0' * 40
-                def region(self, wire):
+                def _region(self, wire):
                     repo_id = wire.get('repo_id', '')
                     cache_namespace_uid = 'cache_repo.{}'.format(repo_id)
                     return rc_cache.get_or_create_region('repo_object', cache_namespace_uid)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages