further cleanup of UsersGroup

Renaming some names ... but trying not to change API or database scheme.

--HG--
branch : beta
extra : amend_source : 0158273b2595748ad5ce7604dce7e2c0c97870ba

6 files changed, 108 insertions, 108 deletions

diff --git a/rhodecode/tests/api/api_base.py b/rhodecode/tests/api/api_base.py
index 89518211..1f604de7 100644
--- a/rhodecode/tests/api/api_base.py
+++ b/rhodecode/tests/api/api_base.py
@@ -6,7 +6,7 @@ from rhodecode.tests import *
 from rhodecode.lib.compat import json
 from rhodecode.lib.auth import AuthUser
 from rhodecode.model.user import UserModel
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.meta import Session
 from rhodecode.model.scm import ScmModel
@@ -43,19 +43,19 @@ def api_call(test_obj, params):
     return response
 
 
-TEST_USERS_GROUP = 'test_users_group'
+TEST_USER_GROUP = 'test_users_group'
 
 
-def make_users_group(name=TEST_USERS_GROUP):
-    gr = UsersGroupModel().create(name=name)
-    UsersGroupModel().add_user_to_group(users_group=gr,
+def make_users_group(name=TEST_USER_GROUP):
+    gr = UserGroupModel().create(name=name)
+    UserGroupModel().add_user_to_group(users_group=gr,
                                         user=TEST_USER_ADMIN_LOGIN)
     Session().commit()
     return gr
 
 
-def destroy_users_group(name=TEST_USERS_GROUP):
-    UsersGroupModel().delete(users_group=name, force=True)
+def destroy_users_group(name=TEST_USER_GROUP):
+    UserGroupModel().delete(users_group=name, force=True)
     Session().commit()
 
 
@@ -999,10 +999,10 @@ class BaseTestApi(object):
 
     def test_api_get_users_group(self):
         id_, params = _build_data(self.apikey, 'get_users_group',
-                                  usersgroupid=TEST_USERS_GROUP)
+                                  usersgroupid=TEST_USER_GROUP)
         response = api_call(self, params)
 
-        users_group = UsersGroupModel().get_group(TEST_USERS_GROUP)
+        users_group = UserGroupModel().get_group(TEST_USER_GROUP)
         members = []
         for user in users_group.members:
             user = user.user
@@ -1021,13 +1021,13 @@ class BaseTestApi(object):
         response = api_call(self, params)
 
         expected = []
-        for gr_name in [TEST_USERS_GROUP, 'test_users_group2']:
-            users_group = UsersGroupModel().get_group(gr_name)
+        for gr_name in [TEST_USER_GROUP, 'test_users_group2']:
+            users_group = UserGroupModel().get_group(gr_name)
             ret = users_group.get_api_data()
             expected.append(ret)
         self._compare_ok(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group='test_users_group2')
+        UserGroupModel().delete(users_group='test_users_group2')
         Session().commit()
 
     def test_api_create_users_group(self):
@@ -1038,7 +1038,7 @@ class BaseTestApi(object):
 
         ret = {
             'msg': 'created new user group `%s`' % group_name,
-            'users_group': jsonify(UsersGroupModel()\
+            'users_group': jsonify(UserGroupModel()\
                                    .get_by_name(group_name)\
                                    .get_api_data())
         }
@@ -1049,13 +1049,13 @@ class BaseTestApi(object):
 
     def test_api_get_users_group_that_exist(self):
         id_, params = _build_data(self.apikey, 'create_users_group',
-                                  group_name=TEST_USERS_GROUP)
+                                  group_name=TEST_USER_GROUP)
         response = api_call(self, params)
 
-        expected = "user group `%s` already exist" % TEST_USERS_GROUP
+        expected = "user group `%s` already exist" % TEST_USER_GROUP
         self._compare_error(id_, expected, given=response.body)
 
-    @mock.patch.object(UsersGroupModel, 'create', crash)
+    @mock.patch.object(UserGroupModel, 'create', crash)
     def test_api_get_users_group_exception_occurred(self):
         group_name = 'exception_happens'
         id_, params = _build_data(self.apikey, 'create_users_group',
@@ -1067,7 +1067,7 @@ class BaseTestApi(object):
 
     def test_api_add_user_to_users_group(self):
         gr_name = 'test_group'
-        UsersGroupModel().create(gr_name)
+        UserGroupModel().create(gr_name)
         Session().commit()
         id_, params = _build_data(self.apikey, 'add_user_to_users_group',
                                   usersgroupid=gr_name,
@@ -1081,7 +1081,7 @@ class BaseTestApi(object):
                     'success': True}
         self._compare_ok(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
     def test_api_add_user_to_users_group_that_doesnt_exist(self):
@@ -1093,10 +1093,10 @@ class BaseTestApi(object):
         expected = 'user group `%s` does not exist' % 'false-group'
         self._compare_error(id_, expected, given=response.body)
 
-    @mock.patch.object(UsersGroupModel, 'add_user_to_group', crash)
+    @mock.patch.object(UserGroupModel, 'add_user_to_group', crash)
     def test_api_add_user_to_users_group_exception_occurred(self):
         gr_name = 'test_group'
-        UsersGroupModel().create(gr_name)
+        UserGroupModel().create(gr_name)
         Session().commit()
         id_, params = _build_data(self.apikey, 'add_user_to_users_group',
                                   usersgroupid=gr_name,
@@ -1106,13 +1106,13 @@ class BaseTestApi(object):
         expected = 'failed to add member to user group `%s`' % gr_name
         self._compare_error(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
     def test_api_remove_user_from_users_group(self):
         gr_name = 'test_group_3'
-        gr = UsersGroupModel().create(gr_name)
-        UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
+        gr = UserGroupModel().create(gr_name)
+        UserGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         id_, params = _build_data(self.apikey, 'remove_user_from_users_group',
                                   usersgroupid=gr_name,
@@ -1126,14 +1126,14 @@ class BaseTestApi(object):
                     'success': True}
         self._compare_ok(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
-    @mock.patch.object(UsersGroupModel, 'remove_user_from_group', crash)
+    @mock.patch.object(UserGroupModel, 'remove_user_from_group', crash)
     def test_api_remove_user_from_users_group_exception_occurred(self):
         gr_name = 'test_group_3'
-        gr = UsersGroupModel().create(gr_name)
-        UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
+        gr = UserGroupModel().create(gr_name)
+        UserGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         id_, params = _build_data(self.apikey, 'remove_user_from_users_group',
                                   usersgroupid=gr_name,
@@ -1143,7 +1143,7 @@ class BaseTestApi(object):
         expected = 'failed to remove member from user group `%s`' % gr_name
         self._compare_error(id_, expected, given=response.body)
 
-        UsersGroupModel().delete(users_group=gr_name)
+        UserGroupModel().delete(users_group=gr_name)
         Session().commit()
 
     @parameterized.expand([('none', 'repository.none'),
@@ -1224,13 +1224,13 @@ class BaseTestApi(object):
     def test_api_grant_users_group_permission(self, name, perm):
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,
+                                  usersgroupid=TEST_USER_GROUP,
                                   perm=perm)
         response = api_call(self, params)
 
         ret = {
             'msg': 'Granted perm: `%s` for user group: `%s` in repo: `%s`' % (
-                perm, TEST_USERS_GROUP, self.REPO
+                perm, TEST_USER_GROUP, self.REPO
             ),
             'success': True
         }
@@ -1241,7 +1241,7 @@ class BaseTestApi(object):
         perm = 'haha.no.permission'
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,
+                                  usersgroupid=TEST_USER_GROUP,
                                   perm=perm)
         response = api_call(self, params)
 
@@ -1253,28 +1253,28 @@ class BaseTestApi(object):
         perm = 'repository.read'
         id_, params = _build_data(self.apikey, 'grant_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,
+                                  usersgroupid=TEST_USER_GROUP,
                                   perm=perm)
         response = api_call(self, params)
 
         expected = 'failed to edit permission for user group: `%s` in repo: `%s`' % (
-                    TEST_USERS_GROUP, self.REPO
+                    TEST_USER_GROUP, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)
 
     def test_api_revoke_users_group_permission(self):
         RepoModel().grant_users_group_permission(repo=self.REPO,
-                                                 group_name=TEST_USERS_GROUP,
+                                                 group_name=TEST_USER_GROUP,
                                                  perm='repository.read')
         Session().commit()
         id_, params = _build_data(self.apikey, 'revoke_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,)
+                                  usersgroupid=TEST_USER_GROUP,)
         response = api_call(self, params)
 
         expected = {
             'msg': 'Revoked perm for user group: `%s` in repo: `%s`' % (
-                TEST_USERS_GROUP, self.REPO
+                TEST_USER_GROUP, self.REPO
             ),
             'success': True
         }
@@ -1285,10 +1285,10 @@ class BaseTestApi(object):
 
         id_, params = _build_data(self.apikey, 'revoke_users_group_permission',
                                   repoid=self.REPO,
-                                  usersgroupid=TEST_USERS_GROUP,)
+                                  usersgroupid=TEST_USER_GROUP,)
         response = api_call(self, params)
 
         expected = 'failed to edit permission for user group: `%s` in repo: `%s`' % (
-                    TEST_USERS_GROUP, self.REPO
+                    TEST_USER_GROUP, self.REPO
                 )
         self._compare_error(id_, expected, given=response.body)
diff --git a/rhodecode/tests/functional/test_admin_users_groups.py b/rhodecode/tests/functional/test_admin_users_groups.py
index d0339059..b4aba28d 100644
--- a/rhodecode/tests/functional/test_admin_users_groups.py
+++ b/rhodecode/tests/functional/test_admin_users_groups.py
@@ -1,7 +1,7 @@
 from rhodecode.tests import *
-from rhodecode.model.db import UsersGroup, UsersGroupToPerm, Permission
+from rhodecode.model.db import UserGroup, UserGroupToPerm, Permission
 
-TEST_USERS_GROUP = 'admins_test'
+TEST_USER_GROUP = 'admins_test'
 
 
 class TestAdminUsersGroupsController(TestController):
@@ -15,14 +15,14 @@ class TestAdminUsersGroupsController(TestController):
 
     def test_create(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP
+        users_group_name = TEST_USER_GROUP
         response = self.app.post(url('users_groups'),
                                  {'users_group_name': users_group_name,
                                   'active':True})
         response.follow()
 
         self.checkSessionFlash(response,
-                               'created user group %s' % TEST_USERS_GROUP)
+                               'created user group %s' % TEST_USER_GROUP)
 
     def test_new(self):
         response = self.app.get(url('new_users_group'))
@@ -39,7 +39,7 @@ class TestAdminUsersGroupsController(TestController):
 
     def test_delete(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP + 'another'
+        users_group_name = TEST_USER_GROUP + 'another'
         response = self.app.post(url('users_groups'),
                                  {'users_group_name':users_group_name,
                                   'active':True})
@@ -48,27 +48,27 @@ class TestAdminUsersGroupsController(TestController):
         self.checkSessionFlash(response,
                                'created user group %s' % users_group_name)
 
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).one()
 
         response = self.app.delete(url('users_group', id=gr.users_group_id))
 
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).scalar()
 
         self.assertEqual(gr, None)
 
     def test_enable_repository_read_on_group(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP + 'another2'
+        users_group_name = TEST_USER_GROUP + 'another2'
         response = self.app.post(url('users_groups'),
                                  {'users_group_name': users_group_name,
                                   'active': True})
         response.follow()
 
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         self.checkSessionFlash(response,
                                'created user group %s' % users_group_name)
         ## ENABLE REPO CREATE ON A GROUP
@@ -76,13 +76,13 @@ class TestAdminUsersGroupsController(TestController):
                                  {'create_repo_perm': True})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.repository')
         p2 = Permission.get_by_key('hg.fork.none')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             [[x.users_group_id, x.permission_id, ] for x in perms],
@@ -95,13 +95,13 @@ class TestAdminUsersGroupsController(TestController):
                                     {})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.none')
         p2 = Permission.get_by_key('hg.fork.none')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             sorted([[x.users_group_id, x.permission_id, ] for x in perms]),
@@ -110,18 +110,18 @@ class TestAdminUsersGroupsController(TestController):
         )
 
         # DELETE !
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         ugid = ug.users_group_id
         response = self.app.delete(url('users_group', id=ug.users_group_id))
         response = response.follow()
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).scalar()
 
         self.assertEqual(gr, None)
         p = Permission.get_by_key('hg.create.repository')
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group_id == ugid).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group_id == ugid).all()
         perms = [[x.users_group_id,
                   x.permission_id, ] for x in perms]
         self.assertEqual(
@@ -131,13 +131,13 @@ class TestAdminUsersGroupsController(TestController):
 
     def test_enable_repository_fork_on_group(self):
         self.log_user()
-        users_group_name = TEST_USERS_GROUP + 'another2'
+        users_group_name = TEST_USER_GROUP + 'another2'
         response = self.app.post(url('users_groups'),
                                  {'users_group_name': users_group_name,
                                   'active': True})
         response.follow()
 
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         self.checkSessionFlash(response,
                                'created user group %s' % users_group_name)
         ## ENABLE REPO CREATE ON A GROUP
@@ -145,13 +145,13 @@ class TestAdminUsersGroupsController(TestController):
                                  {'fork_repo_perm': True})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.none')
         p2 = Permission.get_by_key('hg.fork.repository')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             [[x.users_group_id, x.permission_id, ] for x in perms],
@@ -164,13 +164,13 @@ class TestAdminUsersGroupsController(TestController):
                                     {})
 
         response.follow()
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         p = Permission.get_by_key('hg.create.none')
         p2 = Permission.get_by_key('hg.fork.none')
         # check if user has this perms, they should be here since
         # defaults are on
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group == ug).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group == ug).all()
 
         self.assertEqual(
             [[x.users_group_id, x.permission_id, ] for x in perms],
@@ -179,18 +179,18 @@ class TestAdminUsersGroupsController(TestController):
         )
 
         # DELETE !
-        ug = UsersGroup.get_by_group_name(users_group_name)
+        ug = UserGroup.get_by_group_name(users_group_name)
         ugid = ug.users_group_id
         response = self.app.delete(url('users_group', id=ug.users_group_id))
         response = response.follow()
-        gr = self.Session.query(UsersGroup)\
-                           .filter(UsersGroup.users_group_name ==
+        gr = self.Session.query(UserGroup)\
+                           .filter(UserGroup.users_group_name ==
                                    users_group_name).scalar()
 
         self.assertEqual(gr, None)
         p = Permission.get_by_key('hg.fork.repository')
-        perms = UsersGroupToPerm.query()\
-            .filter(UsersGroupToPerm.users_group_id == ugid).all()
+        perms = UserGroupToPerm.query()\
+            .filter(UserGroupToPerm.users_group_id == ugid).all()
         perms = [[x.users_group_id,
                   x.permission_id, ] for x in perms]
         self.assertEqual(
diff --git a/rhodecode/tests/models/test_permissions.py b/rhodecode/tests/models/test_permissions.py
index 0efbcbc6..5abb0014 100644
--- a/rhodecode/tests/models/test_permissions.py
+++ b/rhodecode/tests/models/test_permissions.py
@@ -4,11 +4,11 @@ from rhodecode.tests import *
 from rhodecode.tests.models.common import _make_group
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.repo import RepoModel
-from rhodecode.model.db import RepoGroup, User, UsersGroupRepoGroupToPerm
+from rhodecode.model.db import RepoGroup, User, UserGroupRepoGroupToPerm
 from rhodecode.model.user import UserModel
 
 from rhodecode.model.meta import Session
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 from rhodecode.lib.auth import AuthUser
 from rhodecode.tests.api.api_base import create_repo
 
@@ -51,7 +51,7 @@ class TestPermissions(unittest.TestCase):
             ReposGroupModel().delete(self.g2.group_id)
 
         if hasattr(self, 'ug1'):
-            UsersGroupModel().delete(self.ug1, force=True)
+            UserGroupModel().delete(self.ug1, force=True)
 
         Session().commit()
 
@@ -124,10 +124,10 @@ class TestPermissions(unittest.TestCase):
 
     def test_propagated_permission_from_users_group_by_explicit_perms_exist(self):
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
 
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
 
         # set permission to lower
         new_perm = 'repository.none'
@@ -158,10 +158,10 @@ class TestPermissions(unittest.TestCase):
 
     def test_propagated_permission_from_users_group(self):
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
 
-        UsersGroupModel().add_user_to_group(self.ug1, self.u3)
+        UserGroupModel().add_user_to_group(self.ug1, self.u3)
 
         # grant perm for group this should override default permission from user
         new_perm_gr = 'repository.write'
@@ -183,9 +183,9 @@ class TestPermissions(unittest.TestCase):
 
     def test_propagated_permission_from_users_group_lower_weight(self):
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
 
         # set permission to lower
         new_perm_h = 'repository.write'
@@ -299,13 +299,13 @@ class TestPermissions(unittest.TestCase):
                                                 user=self.anon,
                                                 perm='group.none')
         # make group
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
         Session().commit()
 
         # check if user is in the group
-        membrs = [x.user_id for x in UsersGroupModel().get(self.ug1.users_group_id).members]
+        membrs = [x.user_id for x in UserGroupModel().get(self.ug1.users_group_id).members]
         self.assertEqual(membrs, [self.u1.user_id])
         # add some user to that group
 
@@ -324,9 +324,9 @@ class TestPermissions(unittest.TestCase):
                                                        perm='group.read')
         Session().commit()
         # check if the
-        obj = Session().query(UsersGroupRepoGroupToPerm)\
-            .filter(UsersGroupRepoGroupToPerm.group == self.g1)\
-            .filter(UsersGroupRepoGroupToPerm.users_group == self.ug1)\
+        obj = Session().query(UserGroupRepoGroupToPerm)\
+            .filter(UserGroupRepoGroupToPerm.group == self.g1)\
+            .filter(UserGroupRepoGroupToPerm.users_group == self.ug1)\
             .scalar()
         self.assertEqual(obj.permission.permission_name, 'group.read')
 
@@ -440,9 +440,9 @@ class TestPermissions(unittest.TestCase):
         self.assertEqual(u1_auth.permissions['repositories']['myownrepo'],
                          'repository.admin')
         #set his permission as user group, he should still be admin
-        self.ug1 = UsersGroupModel().create('G1')
+        self.ug1 = UserGroupModel().create('G1')
         # add user to group
-        UsersGroupModel().add_user_to_group(self.ug1, self.u1)
+        UserGroupModel().add_user_to_group(self.ug1, self.u1)
         RepoModel().grant_users_group_permission(repo, group_name=self.ug1,
                                                  perm='repository.none')
 
diff --git a/rhodecode/tests/models/test_users.py b/rhodecode/tests/models/test_users.py
index 7ed1a487..01260f80 100644
--- a/rhodecode/tests/models/test_users.py
+++ b/rhodecode/tests/models/test_users.py
@@ -1,12 +1,12 @@
 import unittest
 from rhodecode.tests import *
 
-from rhodecode.model.db import User, UsersGroup, UsersGroupMember, UserEmailMap,\
+from rhodecode.model.db import User, UserGroup, UserGroupMember, UserEmailMap,\
     Permission
 from rhodecode.model.user import UserModel
 
 from rhodecode.model.meta import Session
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 
 
 class TestUser(unittest.TestCase):
@@ -23,18 +23,18 @@ class TestUser(unittest.TestCase):
         self.assertEqual(User.get_by_username(u'test_user'), usr)
 
         # make user group
-        users_group = UsersGroupModel().create('some_example_group')
+        users_group = UserGroupModel().create('some_example_group')
         Session().commit()
 
-        UsersGroupModel().add_user_to_group(users_group, usr)
+        UserGroupModel().add_user_to_group(users_group, usr)
         Session().commit()
 
-        self.assertEqual(UsersGroup.get(users_group.users_group_id), users_group)
-        self.assertEqual(UsersGroupMember.query().count(), 1)
+        self.assertEqual(UserGroup.get(users_group.users_group_id), users_group)
+        self.assertEqual(UserGroupMember.query().count(), 1)
         UserModel().delete(usr.user_id)
         Session().commit()
 
-        self.assertEqual(UsersGroupMember.query().all(), [])
+        self.assertEqual(UserGroupMember.query().all(), [])
 
     def test_additonal_email_as_main(self):
         usr = UserModel().create_or_update(username=u'test_user',
diff --git a/rhodecode/tests/models/test_users_group_permissions_on_groups.py b/rhodecode/tests/models/test_users_group_permissions_on_groups.py
index 1e94bb27..5da2eb1f 100644
--- a/rhodecode/tests/models/test_users_group_permissions_on_groups.py
+++ b/rhodecode/tests/models/test_users_group_permissions_on_groups.py
@@ -10,7 +10,7 @@ from rhodecode.model.meta import Session
 from nose.tools import with_setup
 from rhodecode.tests.models.common import _create_project_tree, check_tree_perms, \
     _get_perms, _check_expected_count, expected_count, _destroy_project_tree
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 from rhodecode.model.repo import RepoModel
 
 
@@ -40,10 +40,10 @@ def setup_module():
     Session().commit()
     test_u2_id = test_u2.user_id
 
-    gr1 = UsersGroupModel().create(name='perms_group_1')
+    gr1 = UserGroupModel().create(name='perms_group_1')
     Session().commit()
     test_u2_gr_id = gr1.users_group_id
-    UsersGroupModel().add_user_to_group(gr1, user=test_u2_id)
+    UserGroupModel().add_user_to_group(gr1, user=test_u2_id)
     Session().commit()
 
     _get_repo_perms = functools.partial(_get_perms, key='repositories',
diff --git a/rhodecode/tests/test_validators.py b/rhodecode/tests/test_validators.py
index cc1718ae..2f34855c 100644
--- a/rhodecode/tests/test_validators.py
+++ b/rhodecode/tests/test_validators.py
@@ -5,7 +5,7 @@ import formencode
 from rhodecode.tests import *
 
 from rhodecode.model import validators as v
-from rhodecode.model.users_group import UsersGroupModel
+from rhodecode.model.users_group import UserGroupModel
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repos_group import ReposGroupModel
@@ -51,25 +51,25 @@ class TestReposGroups(unittest.TestCase):
         self.assertEqual(TEST_USER_ADMIN_LOGIN,
                          validator.to_python(TEST_USER_ADMIN_LOGIN))
 
-    def test_ValidUsersGroup(self):
-        validator = v.ValidUsersGroup()
+    def test_ValidUserGroup(self):
+        validator = v.ValidUserGroup()
         self.assertRaises(formencode.Invalid, validator.to_python, 'default')
         self.assertRaises(formencode.Invalid, validator.to_python, '.,')
 
-        gr = UsersGroupModel().create('test')
-        gr2 = UsersGroupModel().create('tes2')
+        gr = UserGroupModel().create('test')
+        gr2 = UserGroupModel().create('tes2')
         Session.commit()
         self.assertRaises(formencode.Invalid, validator.to_python, 'test')
         assert gr.users_group_id != None
-        validator = v.ValidUsersGroup(edit=True,
+        validator = v.ValidUserGroup(edit=True,
                                     old_data={'users_group_id':
                                               gr2.users_group_id})
 
         self.assertRaises(formencode.Invalid, validator.to_python, 'test')
         self.assertRaises(formencode.Invalid, validator.to_python, 'TesT')
         self.assertRaises(formencode.Invalid, validator.to_python, 'TEST')
-        UsersGroupModel().delete(gr)
-        UsersGroupModel().delete(gr2)
+        UserGroupModel().delete(gr)
+        UserGroupModel().delete(gr2)
         Session.commit()
 
     def test_ValidReposGroup(self):