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