Mercurial > kallithea

comparison rhodecode/tests/api/api_base.py @ 3647:8a86836fad64 beta

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more usage of fixture tools in tests
author Marcin Kuzminski <marcin@python-works.com>
date Mon, 01 Apr 2013 23:45:25 +0200
parents 7cde75eac0fe
children 7e3d89d9d3a2
comparison
equal deleted inserted replaced
3646:63e49418a4cc 3647:8a86836fad64
1 from __future__ import with_statement 1 from __future__ import with_statement
2 import random 2 import random
3 import mock 3 import mock
4 4
5 from rhodecode.tests import * 5 from rhodecode.tests import *
6 from rhodecode.tests.fixture import Fixture
6 from rhodecode.lib.compat import json 7 from rhodecode.lib.compat import json
7 from rhodecode.lib.auth import AuthUser 8 from rhodecode.lib.auth import AuthUser
8 from rhodecode.model.user import UserModel 9 from rhodecode.model.user import UserModel
9 from rhodecode.model.users_group import UserGroupModel 10 from rhodecode.model.users_group import UserGroupModel
10 from rhodecode.model.repo import RepoModel 11 from rhodecode.model.repo import RepoModel
11 from rhodecode.model.meta import Session 12 from rhodecode.model.meta import Session
12 from rhodecode.model.scm import ScmModel 13 from rhodecode.model.scm import ScmModel
13 from rhodecode.model.db import Repository 14 from rhodecode.model.db import Repository
14 15
16
15 API_URL = '/_admin/api' 17 API_URL = '/_admin/api'
18 TEST_USER_GROUP = 'test_users_group'
19
20 fixture = Fixture()
16 21
17 22
18 def _build_data(apikey, method, **kw): 23 def _build_data(apikey, method, **kw):
19 """ 24 """
20 Builds API data with given random ID 25 Builds API data with given random ID
41 response = test_obj.app.post(API_URL, content_type='application/json', 46 response = test_obj.app.post(API_URL, content_type='application/json',
42 params=params) 47 params=params)
43 return response 48 return response
44 49
45 50
46 TEST_USER_GROUP = 'test_users_group' 51 ## helpers
47
48
49 def make_users_group(name=TEST_USER_GROUP): 52 def make_users_group(name=TEST_USER_GROUP):
50 gr = UserGroupModel().create(name=name) 53 gr = UserGroupModel().create(name=name)
51 UserGroupModel().add_user_to_group(users_group=gr, 54 UserGroupModel().add_user_to_group(users_group=gr,
52 user=TEST_USER_ADMIN_LOGIN) 55 user=TEST_USER_ADMIN_LOGIN)
53 Session().commit() 56 Session().commit()
54 return gr 57 return gr
55 58
56 59
57 def destroy_users_group(name=TEST_USER_GROUP): 60 def destroy_users_group(name=TEST_USER_GROUP):
58 UserGroupModel().delete(users_group=name, force=True) 61 UserGroupModel().delete(users_group=name, force=True)
59 Session().commit()
60
61
62 def create_repo(repo_name, repo_type, owner=None):
63 # create new repo
64 form_data = _get_repo_create_params(
65 repo_name_full=repo_name,
66 repo_description='description %s' % repo_name,
67 )
68 cur_user = UserModel().get_by_username(owner or TEST_USER_ADMIN_LOGIN)
69 r = RepoModel().create(form_data, cur_user)
70 Session().commit()
71 return r
72
73
74 def create_fork(fork_name, fork_type, fork_of):
75 fork = RepoModel(Session())._get_repo(fork_of)
76 r = create_repo(fork_name, fork_type)
77 r.fork = fork
78 Session().add(r)
79 Session().commit()
80 return r
81
82
83 def destroy_repo(repo_name):
84 RepoModel().delete(repo_name)
85 Session().commit() 62 Session().commit()
86 63
87 64
88 class BaseTestApi(object): 65 class BaseTestApi(object):
89 REPO = None 66 REPO = None
246 def test_api_pull(self): 223 def test_api_pull(self):
247 #TODO: issues with rhodecode_extras here.. not sure why ! 224 #TODO: issues with rhodecode_extras here.. not sure why !
248 pass 225 pass
249 226
250 # repo_name = 'test_pull' 227 # repo_name = 'test_pull'
251 # r = create_repo(repo_name, self.REPO_TYPE) 228 # r = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
252 # r.clone_uri = TEST_self.REPO 229 # r.clone_uri = TEST_self.REPO
253 # Session.add(r) 230 # Session.add(r)
254 # Session.commit() 231 # Session.commit()
255 # 232 #
256 # id_, params = _build_data(self.apikey, 'pull', 233 # id_, params = _build_data(self.apikey, 'pull',
259 # params=params) 236 # params=params)
260 # 237 #
261 # expected = 'Pulled from `%s`' % repo_name 238 # expected = 'Pulled from `%s`' % repo_name
262 # self._compare_ok(id_, expected, given=response.body) 239 # self._compare_ok(id_, expected, given=response.body)
263 # 240 #
264 # destroy_repo(repo_name) 241 # fixture.destroy_repo(repo_name)
265 242
266 def test_api_pull_error(self): 243 def test_api_pull_error(self):
267 id_, params = _build_data(self.apikey, 'pull', 244 id_, params = _build_data(self.apikey, 'pull',
268 repoid=self.REPO,) 245 repoid=self.REPO,)
269 response = api_call(self, params) 246 response = api_call(self, params)
315 % (TEST_USER_ADMIN_LOGIN, self.REPO, True)) 292 % (TEST_USER_ADMIN_LOGIN, self.REPO, True))
316 self._compare_ok(id_, expected, given=response.body) 293 self._compare_ok(id_, expected, given=response.body)
317 294
318 def test_api_lock_repo_lock_aquire_by_non_admin(self): 295 def test_api_lock_repo_lock_aquire_by_non_admin(self):
319 repo_name = 'api_delete_me' 296 repo_name = 'api_delete_me'
320 create_repo(repo_name, self.REPO_TYPE, owner=self.TEST_USER_LOGIN) 297 fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,
298 cur_user=self.TEST_USER_LOGIN)
321 try: 299 try:
322 id_, params = _build_data(self.apikey_regular, 'lock', 300 id_, params = _build_data(self.apikey_regular, 'lock',
323 repoid=repo_name, 301 repoid=repo_name,
324 locked=True) 302 locked=True)
325 response = api_call(self, params) 303 response = api_call(self, params)
326 expected = ('User `%s` set lock state for repo `%s` to `%s`' 304 expected = ('User `%s` set lock state for repo `%s` to `%s`'
327 % (self.TEST_USER_LOGIN, repo_name, True)) 305 % (self.TEST_USER_LOGIN, repo_name, True))
328 self._compare_ok(id_, expected, given=response.body) 306 self._compare_ok(id_, expected, given=response.body)
329 finally: 307 finally:
330 destroy_repo(repo_name) 308 fixture.destroy_repo(repo_name)
331 309
332 def test_api_lock_repo_lock_aquire_non_admin_with_userid(self): 310 def test_api_lock_repo_lock_aquire_non_admin_with_userid(self):
333 repo_name = 'api_delete_me' 311 repo_name = 'api_delete_me'
334 create_repo(repo_name, self.REPO_TYPE, owner=self.TEST_USER_LOGIN) 312 fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,
313 cur_user=self.TEST_USER_LOGIN)
335 try: 314 try:
336 id_, params = _build_data(self.apikey_regular, 'lock', 315 id_, params = _build_data(self.apikey_regular, 'lock',
337 userid=TEST_USER_ADMIN_LOGIN, 316 userid=TEST_USER_ADMIN_LOGIN,
338 repoid=repo_name, 317 repoid=repo_name,
339 locked=True) 318 locked=True)
340 response = api_call(self, params) 319 response = api_call(self, params)
341 expected = 'userid is not the same as your user' 320 expected = 'userid is not the same as your user'
342 self._compare_error(id_, expected, given=response.body) 321 self._compare_error(id_, expected, given=response.body)
343 finally: 322 finally:
344 destroy_repo(repo_name) 323 fixture.destroy_repo(repo_name)
345 324
346 def test_api_lock_repo_lock_aquire_non_admin_not_his_repo(self): 325 def test_api_lock_repo_lock_aquire_non_admin_not_his_repo(self):
347 id_, params = _build_data(self.apikey_regular, 'lock', 326 id_, params = _build_data(self.apikey_regular, 'lock',
348 repoid=self.REPO, 327 repoid=self.REPO,
349 locked=True) 328 locked=True)
768 'msg': 'Created new repository `%s`' % repo_name, 747 'msg': 'Created new repository `%s`' % repo_name,
769 'repo': jsonify(repo.get_api_data()) 748 'repo': jsonify(repo.get_api_data())
770 } 749 }
771 expected = ret 750 expected = ret
772 self._compare_ok(id_, expected, given=response.body) 751 self._compare_ok(id_, expected, given=response.body)
773 destroy_repo(repo_name) 752 fixture.destroy_repo(repo_name)
774 753
775 def test_api_create_repo_unknown_owner(self): 754 def test_api_create_repo_unknown_owner(self):
776 repo_name = 'api-repo' 755 repo_name = 'api-repo'
777 owner = 'i-dont-exist' 756 owner = 'i-dont-exist'
778 id_, params = _build_data(self.apikey, 'create_repo', 757 id_, params = _build_data(self.apikey, 'create_repo',
798 'msg': 'Created new repository `%s`' % repo_name, 777 'msg': 'Created new repository `%s`' % repo_name,
799 'repo': jsonify(repo.get_api_data()) 778 'repo': jsonify(repo.get_api_data())
800 } 779 }
801 expected = ret 780 expected = ret
802 self._compare_ok(id_, expected, given=response.body) 781 self._compare_ok(id_, expected, given=response.body)
803 destroy_repo(repo_name) 782 fixture.destroy_repo(repo_name)
804 783
805 def test_api_create_repo_by_non_admin(self): 784 def test_api_create_repo_by_non_admin(self):
806 repo_name = 'api-repo' 785 repo_name = 'api-repo'
807 owner = 'i-dont-exist' 786 owner = 'i-dont-exist'
808 id_, params = _build_data(self.apikey_regular, 'create_repo', 787 id_, params = _build_data(self.apikey_regular, 'create_repo',
816 'msg': 'Created new repository `%s`' % repo_name, 795 'msg': 'Created new repository `%s`' % repo_name,
817 'repo': jsonify(repo.get_api_data()) 796 'repo': jsonify(repo.get_api_data())
818 } 797 }
819 expected = ret 798 expected = ret
820 self._compare_ok(id_, expected, given=response.body) 799 self._compare_ok(id_, expected, given=response.body)
821 destroy_repo(repo_name) 800 fixture.destroy_repo(repo_name)
822 801
823 def test_api_create_repo_by_non_admin_specify_owner(self): 802 def test_api_create_repo_by_non_admin_specify_owner(self):
824 repo_name = 'api-repo' 803 repo_name = 'api-repo'
825 owner = 'i-dont-exist' 804 owner = 'i-dont-exist'
826 id_, params = _build_data(self.apikey_regular, 'create_repo', 805 id_, params = _build_data(self.apikey_regular, 'create_repo',
830 ) 809 )
831 response = api_call(self, params) 810 response = api_call(self, params)
832 811
833 expected = 'Only RhodeCode admin can specify `owner` param' 812 expected = 'Only RhodeCode admin can specify `owner` param'
834 self._compare_error(id_, expected, given=response.body) 813 self._compare_error(id_, expected, given=response.body)
835 destroy_repo(repo_name) 814 fixture.destroy_repo(repo_name)
836 815
837 def test_api_create_repo_exists(self): 816 def test_api_create_repo_exists(self):
838 repo_name = self.REPO 817 repo_name = self.REPO
839 id_, params = _build_data(self.apikey, 'create_repo', 818 id_, params = _build_data(self.apikey, 'create_repo',
840 repo_name=repo_name, 819 repo_name=repo_name,
857 expected = 'failed to create repository `%s`' % repo_name 836 expected = 'failed to create repository `%s`' % repo_name
858 self._compare_error(id_, expected, given=response.body) 837 self._compare_error(id_, expected, given=response.body)
859 838
860 def test_api_delete_repo(self): 839 def test_api_delete_repo(self):
861 repo_name = 'api_delete_me' 840 repo_name = 'api_delete_me'
862 create_repo(repo_name, self.REPO_TYPE) 841 fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
863 842
864 id_, params = _build_data(self.apikey, 'delete_repo', 843 id_, params = _build_data(self.apikey, 'delete_repo',
865 repoid=repo_name,) 844 repoid=repo_name,)
866 response = api_call(self, params) 845 response = api_call(self, params)
867 846
872 expected = ret 851 expected = ret
873 self._compare_ok(id_, expected, given=response.body) 852 self._compare_ok(id_, expected, given=response.body)
874 853
875 def test_api_delete_repo_by_non_admin(self): 854 def test_api_delete_repo_by_non_admin(self):
876 repo_name = 'api_delete_me' 855 repo_name = 'api_delete_me'
877 create_repo(repo_name, self.REPO_TYPE, owner=self.TEST_USER_LOGIN) 856 fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,
857 cur_user=self.TEST_USER_LOGIN)
878 try: 858 try:
879 id_, params = _build_data(self.apikey_regular, 'delete_repo', 859 id_, params = _build_data(self.apikey_regular, 'delete_repo',
880 repoid=repo_name,) 860 repoid=repo_name,)
881 response = api_call(self, params) 861 response = api_call(self, params)
882 862
885 'success': True 865 'success': True
886 } 866 }
887 expected = ret 867 expected = ret
888 self._compare_ok(id_, expected, given=response.body) 868 self._compare_ok(id_, expected, given=response.body)
889 finally: 869 finally:
890 destroy_repo(repo_name) 870 fixture.destroy_repo(repo_name)
891 871
892 def test_api_delete_repo_by_non_admin_no_permission(self): 872 def test_api_delete_repo_by_non_admin_no_permission(self):
893 repo_name = 'api_delete_me' 873 repo_name = 'api_delete_me'
894 create_repo(repo_name, self.REPO_TYPE) 874 fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
895 try: 875 try:
896 id_, params = _build_data(self.apikey_regular, 'delete_repo', 876 id_, params = _build_data(self.apikey_regular, 'delete_repo',
897 repoid=repo_name,) 877 repoid=repo_name,)
898 response = api_call(self, params) 878 response = api_call(self, params)
899 expected = 'repository `%s` does not exist' % (repo_name) 879 expected = 'repository `%s` does not exist' % (repo_name)
900 self._compare_error(id_, expected, given=response.body) 880 self._compare_error(id_, expected, given=response.body)
901 finally: 881 finally:
902 destroy_repo(repo_name) 882 fixture.destroy_repo(repo_name)
903 883
904 def test_api_delete_repo_exception_occurred(self): 884 def test_api_delete_repo_exception_occurred(self):
905 repo_name = 'api_delete_me' 885 repo_name = 'api_delete_me'
906 create_repo(repo_name, self.REPO_TYPE) 886 fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
907 try: 887 try:
908 with mock.patch.object(RepoModel, 'delete', crash): 888 with mock.patch.object(RepoModel, 'delete', crash):
909 id_, params = _build_data(self.apikey, 'delete_repo', 889 id_, params = _build_data(self.apikey, 'delete_repo',
910 repoid=repo_name,) 890 repoid=repo_name,)
911 response = api_call(self, params) 891 response = api_call(self, params)
912 892
913 expected = 'failed to delete repository `%s`' % repo_name 893 expected = 'failed to delete repository `%s`' % repo_name
914 self._compare_error(id_, expected, given=response.body) 894 self._compare_error(id_, expected, given=response.body)
915 finally: 895 finally:
916 destroy_repo(repo_name) 896 fixture.destroy_repo(repo_name)
917 897
918 def test_api_fork_repo(self): 898 def test_api_fork_repo(self):
919 fork_name = 'api-repo-fork' 899 fork_name = 'api-repo-fork'
920 id_, params = _build_data(self.apikey, 'fork_repo', 900 id_, params = _build_data(self.apikey, 'fork_repo',
921 repoid=self.REPO, 901 repoid=self.REPO,
929 fork_name), 909 fork_name),
930 'success': True 910 'success': True
931 } 911 }
932 expected = ret 912 expected = ret
933 self._compare_ok(id_, expected, given=response.body) 913 self._compare_ok(id_, expected, given=response.body)
934 destroy_repo(fork_name) 914 fixture.destroy_repo(fork_name)
935 915
936 def test_api_fork_repo_non_admin(self): 916 def test_api_fork_repo_non_admin(self):
937 fork_name = 'api-repo-fork' 917 fork_name = 'api-repo-fork'
938 id_, params = _build_data(self.apikey_regular, 'fork_repo', 918 id_, params = _build_data(self.apikey_regular, 'fork_repo',
939 repoid=self.REPO, 919 repoid=self.REPO,
946 fork_name), 926 fork_name),
947 'success': True 927 'success': True
948 } 928 }
949 expected = ret 929 expected = ret
950 self._compare_ok(id_, expected, given=response.body) 930 self._compare_ok(id_, expected, given=response.body)
951 destroy_repo(fork_name) 931 fixture.destroy_repo(fork_name)
952 932
953 def test_api_fork_repo_non_admin_specify_owner(self): 933 def test_api_fork_repo_non_admin_specify_owner(self):
954 fork_name = 'api-repo-fork' 934 fork_name = 'api-repo-fork'
955 id_, params = _build_data(self.apikey_regular, 'fork_repo', 935 id_, params = _build_data(self.apikey_regular, 'fork_repo',
956 repoid=self.REPO, 936 repoid=self.REPO,
958 owner=TEST_USER_ADMIN_LOGIN, 938 owner=TEST_USER_ADMIN_LOGIN,
959 ) 939 )
960 response = api_call(self, params) 940 response = api_call(self, params)
961 expected = 'Only RhodeCode admin can specify `owner` param' 941 expected = 'Only RhodeCode admin can specify `owner` param'
962 self._compare_error(id_, expected, given=response.body) 942 self._compare_error(id_, expected, given=response.body)
963 destroy_repo(fork_name) 943 fixture.destroy_repo(fork_name)
964 944
965 def test_api_fork_repo_non_admin_no_permission_to_fork(self): 945 def test_api_fork_repo_non_admin_no_permission_to_fork(self):
966 RepoModel().grant_user_permission(repo=self.REPO, 946 RepoModel().grant_user_permission(repo=self.REPO,
967 user=self.TEST_USER_LOGIN, 947 user=self.TEST_USER_LOGIN,
968 perm='repository.none') 948 perm='repository.none')
972 fork_name=fork_name, 952 fork_name=fork_name,
973 ) 953 )
974 response = api_call(self, params) 954 response = api_call(self, params)
975 expected = 'repository `%s` does not exist' % (self.REPO) 955 expected = 'repository `%s` does not exist' % (self.REPO)
976 self._compare_error(id_, expected, given=response.body) 956 self._compare_error(id_, expected, given=response.body)
977 destroy_repo(fork_name) 957 fixture.destroy_repo(fork_name)
978 958
979 def test_api_fork_repo_unknown_owner(self): 959 def test_api_fork_repo_unknown_owner(self):
980 fork_name = 'api-repo-fork' 960 fork_name = 'api-repo-fork'
981 owner = 'i-dont-exist' 961 owner = 'i-dont-exist'
982 id_, params = _build_data(self.apikey, 'fork_repo', 962 id_, params = _build_data(self.apikey, 'fork_repo',
988 expected = 'user `%s` does not exist' % owner 968 expected = 'user `%s` does not exist' % owner
989 self._compare_error(id_, expected, given=response.body) 969 self._compare_error(id_, expected, given=response.body)
990 970
991 def test_api_fork_repo_fork_exists(self): 971 def test_api_fork_repo_fork_exists(self):
992 fork_name = 'api-repo-fork' 972 fork_name = 'api-repo-fork'
993 create_fork(fork_name, self.REPO_TYPE, self.REPO) 973 fixture.create_fork(self.REPO, fork_name)
994 974
995 try: 975 try:
996 fork_name = 'api-repo-fork' 976 fork_name = 'api-repo-fork'
997 977
998 id_, params = _build_data(self.apikey, 'fork_repo', 978 id_, params = _build_data(self.apikey, 'fork_repo',
1003 response = api_call(self, params) 983 response = api_call(self, params)
1004 984
1005 expected = "fork `%s` already exist" % fork_name 985 expected = "fork `%s` already exist" % fork_name
1006 self._compare_error(id_, expected, given=response.body) 986 self._compare_error(id_, expected, given=response.body)
1007 finally: 987 finally:
1008 destroy_repo(fork_name) 988 fixture.destroy_repo(fork_name)
1009 989
1010 def test_api_fork_repo_repo_exists(self): 990 def test_api_fork_repo_repo_exists(self):
1011 fork_name = self.REPO 991 fork_name = self.REPO
1012 992
1013 id_, params = _build_data(self.apikey, 'fork_repo', 993 id_, params = _build_data(self.apikey, 'fork_repo',