diff options
Diffstat (limited to 'github3/tests')
| -rw-r--r-- | github3/tests/api_test.py | 124 | ||||
| -rw-r--r-- | github3/tests/converters_test.py | 96 | ||||
| -rw-r--r-- | github3/tests/fixtures.py | 164 | ||||
| -rw-r--r-- | github3/tests/get_handlers_test.py | 31 | ||||
| -rw-r--r-- | github3/tests/gists_handler_test.py | 110 | ||||
| -rw-r--r-- | github3/tests/handler_test.py | 133 | ||||
| -rw-r--r-- | github3/tests/user_handler_test.py | 326 |
7 files changed, 984 insertions, 0 deletions
diff --git a/github3/tests/api_test.py b/github3/tests/api_test.py new file mode 100644 index 0000000..3ae75ee --- /dev/null +++ b/github3/tests/api_test.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +from mock import Mock, patch +from unittest import TestCase +from github3 import api +from github3.exceptions import * +import json +import requests + + +@patch.object(requests.sessions.Session, 'request') +class TestGithubCore(TestCase): + + def setUp(self): + self.gh = api.GithubCore() + self.assertEquals(self.gh.base_url, 'https://api.github.com/') + self.assertEquals(self.gh._parser, json) + self.base_url = self.gh.base_url + self.parser = self.gh._parser + + def test_parse_args(self, request_method): + args = { + 'data': {'some': 'data'}, + 'params': {'arg0': 'some'}, + 'headers': 'out', + 'auth': 'out', + 'arg1': 'some', + 'arg2': 'some', + 'arg3': {'some': 'data', 'are': {'nested': 'true'}}, + } + self.gh._parse_args(args) + self.assertEquals(args, { + 'data': {'some': 'data'}, + 'params': {'arg0': 'some', 'arg1': 'some', 'arg2': 'some', + 'arg3': {'some': 'data', 'are': {'nested': 'true'}}}, + 'headers': 'out', + 'auth': 'out', + }) + + def test_raise_errors(self, request_method): + real_request = (self.gh._request, 'GET', 'test') + request_method.return_value.status_code = 404 + self.assertRaises(NotFound, *real_request) + + request_method.return_value.status_code = 400 + self.assertRaises(BadRequest, *real_request) + + request_method.return_value.status_code = 422 + self.assertRaises(UnprocessableEntity, *real_request) + + request_method.return_value.status_code = 401 + self.assertRaises(Unauthorized, *real_request) + + def test_get(self, request_method): + response = request_method.return_value + response.content = self.parser.dumps({'test': 'test'}) + content = self.gh.get('core') + request_method.assert_called_with('GET', self.base_url + 'core') + self.assertEquals(content, {'test': 'test'}) + + response = request_method.return_value + response.headers = {'link': 'url_with_links'} + response.content = self.parser.dumps({'test': 'test'}) + header, content = self.gh.get('core', paginate=True) + request_method.assert_called_with('GET', self.base_url + 'core') + self.assertEquals(header, 'url_with_links') + self.assertEquals(content, {'test': 'test'}) + + def test_head(self, request_method): + pass # It has no sense using mocks + + def test_post_and_patch(self, request_method): + data = {'login': 'test', 'bio': 'test'} + response = request_method.return_value + response.status_code = 201 + response.content = self.parser.dumps({'post': 'done'}) + + content = self.gh.post('core', data=data) + request_method.assert_called_with( + 'POST', self.base_url + 'core', + data=self.parser.dumps(data)) + self.assertEquals(content, {'post': 'done'}) + + content = self.gh.post('core') + request_method.assert_called_with( + 'POST', self.base_url + 'core', + data=self.parser.dumps(None)) + self.assertEquals(content, {'post': 'done'}) + + response.status_code = 200 + content = self.gh.patch('core', data=data) + request_method.assert_called_with( + 'PATCH', self.base_url + 'core', + data=self.parser.dumps(data)) + self.assertEquals(content, {'post': 'done'}) + + content = self.gh.patch('core') + request_method.assert_called_with( + 'PATCH', self.base_url + 'core', + data=self.parser.dumps(None)) + self.assertEquals(content, {'post': 'done'}) + + def test_delete(self, request_method): + data = {'test': 'test'} + response = request_method.return_value + response.status_code = 204 + response.content = self.parser.dumps({'delete': 'done'}) + delete = self.gh.delete('core', data=data) + request_method.assert_called_with( + 'DELETE', self.base_url + 'core', + data=self.parser.dumps(data)) + delete = self.gh.delete('core') + request_method.assert_called_with( + 'DELETE', self.base_url + 'core') + + def test_put(self, request_method): + response = request_method.return_value + response.status_code = 204 + response.content = '' + put = self.gh.put('core') + request_method.assert_called_with( + 'PUT', self.base_url + 'core', + headers={'Content-length': '0'}) diff --git a/github3/tests/converters_test.py b/github3/tests/converters_test.py new file mode 100644 index 0000000..66eedc3 --- /dev/null +++ b/github3/tests/converters_test.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +from github3.converters import * +from github3.models.base import BaseResource +from unittest import TestCase +from datetime import datetime + +API_STUB = { + 'test_str': 'string', + 'test_int': 1, + 'test_date': '2008-01-14T04:33:35Z', + 'test_bool': True, + 'map': {'test_str': 'string'}, + 'dict_map': { + 'map1': { + 'test_str': 'string', + 'test_int': 1 + }, + 'map2': { + 'test_str': 'string', + 'test_int': 2 + }, + }, + 'list_map': [ + {'test_str': 'string', 'test_int': 1}, + {'test_str': 'string', 'test_int': 2}, + ], + 'fake_map': 9, +} + + +class Model(BaseResource): + + @classmethod + def idl(self): + return { + 'strs': ['test_str'], + 'ints': ['test_int'], + 'dates': ['test_date'], + 'bools': ['test_bool'], + 'maps': {'map': Model, 'fake_map': Model}, + 'collection_maps': { + 'dict_map': Model, + 'list_map': Model, + 'fake_map': Model, + }, + } + + +class TestModelizer(TestCase): + + def setUp(self): + model = Model + self.modelizer = Modelizer() + self.modelizer.inject(model) + + def test_loads(self): + parsed_model = self.modelizer.loads(API_STUB) + self.assertEquals(len(parsed_model), len(API_STUB)) + self.assertEquals(parsed_model.test_str, 'string') + self.assertEquals(parsed_model.test_int, 1) + self.assertEquals( + parsed_model.test_date, + datetime(2008, 1, 14, 4, 33, 35)) + self.assertTrue(parsed_model.test_bool) + self.assertTrue(isinstance(parsed_model.map, Model)) + self.assertEquals(parsed_model.map.test_str, 'string') + self.assertTrue(isinstance(parsed_model.dict_map, dict)) + map1 = parsed_model.dict_map['map1'] + map2 = parsed_model.dict_map['map2'] + self.assertTrue(isinstance(map1, Model)) + self.assertTrue(isinstance(map2, Model)) + self.assertEquals(map1.test_str, 'string') + self.assertEquals(map1.test_int, 1) + self.assertEquals(map2.test_str, 'string') + self.assertEquals(map2.test_int, 2) + + list_map = parsed_model.list_map + self.assertTrue(isinstance(list_map, list)) + self.assertEquals(list_map[0].test_str, 'string') + self.assertEquals(list_map[0].test_int, 1) + self.assertEquals(list_map[1].test_str, 'string') + self.assertEquals(list_map[1].test_int, 2) + + +class TestRawlizer(TestCase): + + def setUp(self): + model = Model + self.rawlizer = Rawlizer() + + # Trivial, I know it + def test_loads(self): + raw = self.rawlizer.loads(API_STUB) + self.assertEquals(raw, API_STUB) diff --git a/github3/tests/fixtures.py b/github3/tests/fixtures.py new file mode 100644 index 0000000..ff5179c --- /dev/null +++ b/github3/tests/fixtures.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +GET_USER = { + "login": "octocat", + "id": 1, + "avatar_url": "https://github.com/images/error/octocat_happy.gif", + "gravatar_id": "somehexcode", + "url": "https://api.github.com/users/octocat", + "name": "monalisa octocat", + "company": "GitHub", + "blog": "https://github.com/blog", + "location": "San Francisco", + "email": "octocat@github.com", + "hireable": False, + "bio": "There once was...", + "public_repos": 2, + "public_gists": 1, + "followers": 20, + "following": 0, + "html_url": "https://github.com/octocat", + "created_at": "2008-01-14T04:33:35Z", + "type": "User" +} + +GET_LINK = '<https://api.github.com/it_doesnt_matter?page=2>; rel="next", \ +<https://api.github.com/it_doesnt_matter?page=5>; rel="last"' + +GET_RESOURCES = [ + {'login': 'octocat'}, + {'login': 'octocat'} +] + +GET_SHORT_USERS = [ + { + "login": "octocat", + "id": 1, + "avatar_url": "https://github.com/images/error/octocat_happy.gif", + "gravatar_id": "somehexcode", + "url": "https://api.github.com/users/octocat" + }, + { + "login": "octocat", + "id": 1, + "avatar_url": "https://github.com/images/error/octocat_happy.gif", + "gravatar_id": "somehexcode", + "url": "https://api.github.com/users/octocat" + }, +] + +GET_SHORT_ORGS = [ + { + "login": "github", + "id": 1, + "url": "https://api.github.com/orgs/1", + "avatar_url": "https://github.com/images/error/octocat_happy.gif" + } +] + +GET_SHORT_REPOS = [ + { + "url": "https://api.github.com/repos/octocat/Hello-World", + "html_url": "https://github.com/octocat/Hello-World", + "clone_url": "https://github.com/octocat/Hello-World.git", + "git_url": "git://github.com/octocat/Hello-World.git", + "ssh_url": "git@github.com:octocat/Hello-World.git", + "svn_url": "https://svn.github.com/octocat/Hello-World", + "owner": { + "login": "octocat", + "id": 1, + "avatar_url": "https://github.com/images/error/octocat_happy.gif", + "gravatar_id": "somehexcode", + "url": "https://api.github.com/users/octocat" + }, + "name": "Hello-World", + "description": "This your first repo!", + "homepage": "https://github.com", + "language": None, + "private": False, + "fork": False, + "forks": 9, + "watchers": 80, + "size": 108, + "master_branch": "master", + "open_issues": 0, + "pushed_at": "2011-01-26T19:06:43Z", + "created_at": "2011-01-26T19:01:12Z" + } +] + +GET_SHORT_GISTS = [ + { + "url": "https://api.github.com/gists/1", + "id": "1", + "description": "description of gist", + "public": True, + "user": { + "login": "octocat", + "id": 1, + "avatar_url": "https://github.com/images/error/octocat_happy.gif", + "gravatar_id": "somehexcode", + "url": "https://api.github.com/users/octocat" + }, + "files": { + "ring.erl": { + "size": 932, + "filename": "ring.erl", + "raw_url": "https://gist.github.com/raw/365370/8c4d2d43d178df\ + 44f4c03a7f2ac0ff512853564e/ring.erl", + "content": "contents of gist" + } + }, + "comments": 0, + "html_url": "https://gist.github.com/1", + "git_pull_url": "git://gist.github.com/1.git", + "git_push_url": "git@gist.github.com:1.git", + "created_at": "2010-04-14T02:15:15Z" + } +] +GET_FULL_USER = { + "login": "octocat", + "id": 1, + "avatar_url": "https://github.com/images/error/octocat_happy.gif", + "gravatar_id": "somehexcode", + "url": "https://api.github.com/users/octocat", + "name": "monalisa octocat", + "company": "GitHub", + "blog": "https://github.com/blog", + "location": "San Francisco", + "email": "octocat@github.com", + "hireable": False, + "bio": "There once was...", + "public_repos": 2, + "public_gists": 1, + "followers": 20, + "following": 0, + "html_url": "https://github.com/octocat", + "created_at": "2008-01-14T04:33:35Z", + "type": "User", + "total_private_repos": 100, + "owned_private_repos": 100, + "private_gists": 81, + "disk_usage": 10000, + "collaborators": 8, + "plan": { + "name": "Medium", + "space": 400, + "collaborators": 10, + "private_repos": 20 + } +} +GET_USER_EMAILS = [ + "octocat@github.com", + "support@github.com" +] + +GET_USER_KEYS = [ + { + "url": "https://api.github.com/user/keys/1", + "id": 1, + "title": "octocat@octomac", + "key": "ssh-rsa AAA..." + } +] diff --git a/github3/tests/get_handlers_test.py b/github3/tests/get_handlers_test.py new file mode 100644 index 0000000..0d88670 --- /dev/null +++ b/github3/tests/get_handlers_test.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +from unittest import TestCase +from github3 import api +from github3 import handlers + + +class TestGetHandlers(TestCase): + + def setUp(self): + self.anom_gh = api.Github() + self.auth_gh = api.Github('test', 'password') + + def test_get_user(self): + anom_user = self.anom_gh.users + auth_user = self.auth_gh.users + + self.assertIsInstance(anom_user, handlers.users.User) + self.assertEquals(anom_user.prefix, 'users') + self.assertIsInstance(auth_user, handlers.users.AuthUser) + self.assertEquals(auth_user.prefix, 'user') + + def test_get_gists(self): + anom_gists = self.anom_gh.gists + auth_gists = self.auth_gh.gists + + self.assertIsInstance(anom_gists, handlers.gists.Gist) + self.assertEquals(anom_gists.prefix, 'gists') + self.assertIsInstance(auth_gists, handlers.gists.AuthGist) + self.assertEquals(anom_gists.prefix, 'gists') diff --git a/github3/tests/gists_handler_test.py b/github3/tests/gists_handler_test.py new file mode 100644 index 0000000..ecadcfb --- /dev/null +++ b/github3/tests/gists_handler_test.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +from unittest import TestCase +from mock import Mock, patch +from github3 import api +from github3.models import Gist, GistComment +from github3.handlers.base import Handler + + +class TestGistHandler(TestCase): + + def setUp(self): + self.gh = api.Github() + self.handler = self.gh.gists + + @patch.object(Handler, '_get_resources') + def test_get_gists(self, get): + gists = self.handler.all_gists() + get.assert_called_with('', model=Gist, limit=None) + + @patch.object(Handler, '_get_resource') + def test_get(self, get): + gist = self.handler.get(1) + get.assert_called_with(1, model=Gist) + + @patch.object(Handler, '_get_resources') + def test_get_comments(self, get): + comments = self.handler.get_comments(1) + get.assert_called_with('1/comments', model=GistComment, limit=None, + headers=None) + + @patch.object(Handler, '_get_resource') + def test_get_comment(self, get): + comment = self.handler.get_comment(1) + get.assert_called_with('comments/1', model=GistComment, headers=None) + + +class TestAuthGistHandler(TestCase): + + def setUp(self): + self.gh = api.Github('test', 'pass') + self.handler = self.gh.gists + + def test_inherit(self): + self.assertTrue(hasattr(self.handler, 'get')) + self.assertTrue(hasattr(self.handler, 'get_comments')) + self.assertTrue(hasattr(self.handler, 'get_comment')) + + @patch.object(Handler, '_get_resources') + def test_all_gists(self, get): + gists = self.handler.all_gists() + get.assert_called_with('public', model=Gist, limit=None) + + @patch.object(Handler, '_get_resources') + def test_my_gists(self, get): + gists = self.handler.my_gists() + get.assert_called_with('', model=Gist, limit=None) + + @patch.object(Handler, '_get_resources') + def test_my_starred_gists(self, get): + gists = self.handler.my_starred_gists() + get.assert_called_with('starred', model=Gist, limit=None) + + @patch.object(Handler, '_post_resource') + def test_create_gist(self, post): + data = { + 'public': False, + 'files': {'file': {'contents': 'file_data'}}, + 'desc': 'some' + } + gist = self.handler.create_gist(data['public'], data['files'], + data['desc']) + post.assert_called_with('', data=data, model=Gist) + + @patch.object(Handler, '_put') + def test_star_gist(self, put): + boolean = self.handler.star_gist(1) + put.assert_called_with('1/star') + + @patch.object(Handler, '_delete') + def test_unstar_gist(self, delete): + boolean = self.handler.unstar_gist(1) + delete.assert_callted_with('1/star') + + @patch.object(Handler, '_bool') + def test_is_starred(self, bool): + boolean = self.handler.is_starred(1) + bool.assert_called_with('1/star') + + @patch.object(Handler, '_post_resource') + def test_fork_gist(self, post): + gist = self.handler.fork_gist(1) + post.assert_called_with('1/fork', data=None, model=Gist) + + @patch.object(Handler, '_delete') + def test_delete_gist(self, delete): + boolean = self.handler.delete_gist(1) + delete.assert_called_with('1') + + @patch.object(Handler, '_post_resource') + def test_create_comment(self, post): + gist_comment = self.handler.create_comment(1, 'comment') + post.assert_called_with('1/comments', data={'body': 'comment'}, + model=GistComment) + + @patch.object(Handler, '_delete') + def test_delete_comment(self, delete): + boolean = self.handler.delete_comment(1) + delete.assert_called_with('comments/1') diff --git a/github3/tests/handler_test.py b/github3/tests/handler_test.py new file mode 100644 index 0000000..83c89ef --- /dev/null +++ b/github3/tests/handler_test.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +from mock import Mock, patch +from unittest import TestCase +from github3 import api +from github3.handlers.base import Handler, MimeTypeMixin +from github3.exceptions import * +from github3.converters import * +from github3.models.user import User +from fixtures import * +import json +import requests + + +class TestMimeTypeMixin(TestCase): + + def setUp(self): + self.mixin = MimeTypeMixin() + + def _parse_mime_type(self, type): + return 'application/vnd.github.%s.%s+json' % ( + MimeTypeMixin.VERSION, type) + + def test_header(self): + self.assertEquals(self.mixin.mime_header(), None) + + def test_add_mimetypes(self): + self.mixin.add_raw() + self.mixin.add_text() + self.mixin.add_html() + self.mixin.add_full() + self.assertEquals(sorted(self.mixin.mime_header()), sorted({ + 'Accept': '%s, %s, %s, %s' % ( + self._parse_mime_type('raw'), + self._parse_mime_type('text'), + self._parse_mime_type('html'), + self._parse_mime_type('full'))})) + + +class TestHandler(TestCase): + + def setUp(self): + self.gh = api.Github() + self.handler = Handler(self.gh) + + def test_get_converter(self): + self.assertIsInstance(self.handler._get_converter(), Modelizer) + kwargs = {'converter': Rawlizer} + self.assertIsInstance(self.handler._get_converter(kwargs), + Rawlizer) + self.assertEquals(kwargs, {}) + self.handler.converter = Modelizer + self.assertIsInstance(self.handler._get_converter(), Modelizer) + + def test_bool(self): + with patch.object(api.Github, 'head') as head: + response = head.return_value + response.status_code = 204 + bool1 = self.handler._bool('test') + head.side_effect = NotFound() + bool2 = self.handler._bool('test') + head.assert_called_with('test') + self.assertTrue(bool1) + self.assertFalse(bool2) + + with patch.object(api.Github, 'put') as put: + response = put.return_value + response.status_code = 204 + booll = self.handler._put('test') + put.assert_called_with('test', method='put') + self.assertTrue(booll) + + with patch.object(api.Github, 'delete') as delete: + response = delete.return_value + response.content = self.gh._parser.dumps({'data': 'test'}) + response.status_code = 204 + bool1 = self.handler._bool('test', method='delete') + bool2 = self.handler._bool('test', method='delete', + data={'some': 'data'}) + self.assertTrue(bool1) + self.assertTrue(bool2) + + @patch.object(api.Github, '_request') + def test_get_resources(self, request): + # Simulating per_page=2 with STUB (it returns two resources) + response = request.return_value + response.status_code = 200 + response.headers = {'link': GET_LINK} + response.content = self.gh._parser.dumps(GET_RESOURCES) + resources = self.handler._get_resources('users', model=User) + self.assertFalse(request.called) + resources = list(resources) + self.assertTrue(request.call_count, 5) + request_args = ('GET', 'users') + self.assertEquals(request.call_args_list, [ + (request_args, {'page': 1}), + (request_args, {'page': 2}), + (request_args, {'page': 3}), + (request_args, {'page': 4}), + (request_args, {'page': 5})]) + self.assertEquals(len(resources), 10) + self.assertEquals(resources[0].login, 'octocat') + + request.reset_mock() + resources = self.handler._get_resources('users', model=User, limit=5) + resources = list(resources) + self.assertEquals(request.call_count, 3) + self.assertEquals(len(resources), 5) + request.reset_mock() + resources = self.handler._get_resources('users', model=User, limit=4) + resources = list(resources) + self.assertEquals(request.call_count, 2) + self.assertEquals(len(resources), 4) + request.reset_mock() + resources = self.handler._get_resources('users', model=User, limit=-5) + resources = list(resources) + self.assertEquals(request.call_count, 3) + self.assertEquals(len(resources), 5) + + @patch.object(api.Github, 'get') + def test_get_resource(self, get): + # Converter test + api(get) test. Half trivial + get.return_value = {'login': 'octocat'} + model = self.handler._get_resource('test', model=User) + self.assertEquals(model.login, 'octocat') + + @patch.object(api.Github, 'post') + def test_post_resource(self, post): + post.return_value = {'data': 'posted'} + data = {'data': 'to_post'} + user_new = self.handler._post_resource('test', data=data, model=User) + post.assert_called_with('test', data=data) diff --git a/github3/tests/user_handler_test.py b/github3/tests/user_handler_test.py new file mode 100644 index 0000000..33658d2 --- /dev/null +++ b/github3/tests/user_handler_test.py @@ -0,0 +1,326 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +from unittest import TestCase +from mock import Mock, patch +from github3 import api +from fixtures import * +from github3.models import User, AuthUser, Repo, Gist, Org, Key +from github3.exceptions import * +from github3 import handlers + + +class TestAuthUserHandler(TestCase): + """ Test private api about user logged """ + + def setUp(self): + self.gh = api.Github('test', 'pass') + self.handler = self.gh.users + self.user_mock = Mock() + self.user_mock.login = 'user_model' + + def test_inject_user_handler(self): + self.assertEquals(self.handler.get.im_class, handlers.users.User) + self.assertEquals(self.handler.get_followers.im_class, + handlers.users.User) + self.assertEquals(self.handler.get_following.im_class, + handlers.users.User) + self.assertEquals(self.handler.get_repos.im_class, + handlers.users.User) + self.assertEquals(self.handler.get_watched.im_class, + handlers.users.User) + self.assertEquals(self.handler.get_orgs.im_class, + handlers.users.User) + self.assertEquals(self.handler.get_gists.im_class, + handlers.users.User) + + @patch.object(api.Github, 'get') + def test_me(self, get): + get.return_value = GET_FULL_USER + user = self.handler.me() + self.assertIsInstance(user, AuthUser) + get.assert_called_with('user') + self.assertEquals(len(user), len(GET_FULL_USER)) + + @patch.object(handlers.base.Handler, '_get_resource') + def test_get(self, get): + user = self.handler.get('test') + get.assert_called_with('test', model=User) + + @patch.object(handlers.base.Handler, '_get_resources') + def test_get_my_followers(self, get): + followers = self.handler.my_followers() + get.assert_called_with('followers', model=User, limit=None) + + @patch.object(handlers.base.Handler, '_get_resources') + def test_get_my_following(self, get): + following = self.handler.my_following() + get.assert_called_with('following', model=User, limit=None) + + @patch.object(handlers.base.Handler, '_get_resources') + def test_get_my_watched(self, get): + following = self.handler.my_watched() + get.assert_called_with('watched', model=Repo, limit=None) + + @patch.object(handlers.base.Handler, '_get_resources') + def test_get_my_orgs(self, get): + following = self.handler.my_orgs() + get.assert_called_with('orgs', model=Org, limit=None) + + @patch.object(api.Github, 'get') + def test_get_emails(self, get): + get.return_value = GET_USER_EMAILS + emails = self.handler.get_emails() + get.assert_called_with('user/emails') + self.assertEquals(emails, GET_USER_EMAILS) + + @patch.object(api.Github, 'post') + def test_create_emails(self, post): + post.return_value = GET_USER_EMAILS + emails = self.handler.create_emails(*GET_USER_EMAILS) + post.assert_called_with('user/emails', data=GET_USER_EMAILS) + self.assertEquals(emails, GET_USER_EMAILS) + + @patch.object(api.Github, 'delete') + def test_delete_emails(self, delete): + response = delete.return_value + response.return_value = '' + response.status_code = 204 + emails = self.handler.delete_emails(*GET_USER_EMAILS) + delete.assert_called_with('user/emails', data=GET_USER_EMAILS, + method='delete') + self.assertTrue(emails) + + @patch.object(api.Github, 'head') + def test_is_following(self, head): + response = head.return_value + response.status_code = 204 + self.assertTrue(self.handler.is_following('test')) + head.assert_called_with('user/following/test') + self.handler.is_following(self.user_mock) + head.assert_called_with('user/following/user_model') + + @patch.object(api.Github, 'put') + def test_follow(self, put): + response = put.return_value + response.status_code = 204 + self.assertTrue(self.handler.follow('test')) + put.assert_called_with('user/following/test', method='put') + + @patch.object(api.Github, 'delete') + def test_unfollow(self, delete): + response = delete.return_value + response.status_code = 204 + self.assertTrue(self.handler.unfollow('test')) + delete.assert_called_with('user/following/test', method='delete') + + @patch.object(api.Github, '_request') + def test_get_keys(self, request): + response = request.return_value + response.status_code = 200 + response.content = self.gh._parser.dumps(GET_USER_KEYS) + response.headers = {'link': GET_LINK} # 1 per page + keys = list(self.handler.get_keys()) + self.assertEquals(len(keys), 5) + self.assertIsInstance(keys[0], Key) + request.assert_called_with('GET', 'user/keys', page=5) + keys = list(self.handler.get_keys(limit=2)) + self.assertEquals(len(keys), 2) + + @patch.object(api.Github, 'get') + def test_get_key(self, get): + get.return_value = GET_USER_KEYS[0] + key = self.handler.get_key(1) + self.assertIsInstance(key, Key) + get.assert_called_with('user/keys/1') + model_key = Mock() + model_key.id = 1 + key = self.handler.get_key(model_key) + get.assert_called_with('user/keys/1') + + @patch.object(api.Github, 'post') + def test_create_key(self, post): + post.return_value = GET_USER_KEYS[0] + key_data = {'title': 'some', 'key': 'ssh-rsa AAA'} + created_key = self.handler.create_key(**key_data) + self.assertIsInstance(created_key, Key) + post.assert_called_with('user/keys', data=key_data) + + @patch.object(api.Github, 'delete') + def test_delete_key(self, delete): + response = delete.return_value + response.status_code = 204 + self.assertTrue(self.handler.delete_key(1)) + delete.assert_called_with('user/keys/1', method='delete') + model_key = Mock() + model_key.id = 1 + key = self.handler.delete_key(model_key) + delete.assert_called_with('user/keys/1', method='delete') + + @patch.object(api.Github, '_request') + def test_my_repos(self, request): + response = request.return_value + response.status_code = 200 + response.content = self.gh._parser.dumps(GET_SHORT_REPOS) + response.headers = {'link': GET_LINK} # 1 per page + repos = list(self.handler.my_repos(filter='public')) + self.assertEquals(len(repos), 5) + self.assertIsInstance(repos[0], Repo) + request.assert_called_with('GET', 'user/repos', + page=5, type='public') + repos = list(self.handler.my_repos(limit=2)) + self.assertEquals(len(repos), 2) + + @patch.object(api.Github, 'head') + def test_is_watching_repo(self, head): + response = head.return_value + response.status_code = 204 + self.assertTrue(self.handler.is_watching_repo('user', 'repo')) + head.assert_called_with('user/watched/user/repo') + model_user, model_repo = Mock(), Mock() + model_user.login = 'user' + model_repo.name = 'repo' + self.assertTrue(self.handler.is_watching_repo('user', 'repo')) + head.assert_called_with('user/watched/user/repo') + + @patch.object(api.Github, 'put') + def test_watch_repo(self, put): + response = put.return_value + response.status_code = 204 + self.assertTrue(self.handler.watch_repo('user', 'repo')) + put.assert_called_with('user/watched/user/repo', method='put') + model_user, model_repo = Mock(), Mock() + model_user.login = 'user' + model_repo.name = 'repo' + self.assertTrue(self.handler.watch_repo('user', 'repo')) + put.assert_called_with('user/watched/user/repo', method='put') + + @patch.object(api.Github, 'delete') + def test_unwatch_repo(self, delete): + response = delete.return_value + response.status_code = 204 + self.assertTrue(self.handler.unwatch_repo('user', 'repo')) + delete.assert_called_with('user/watched/user/repo', method='delete') + model_user, model_repo = Mock(), Mock() + model_user.login = 'user' + model_repo.name = 'repo' + self.assertTrue(self.handler.unwatch_repo('user', 'repo')) + delete.assert_called_with('user/watched/user/repo', method='delete') + + +class TestUserHandler(TestCase): + """ Test public api about users """ + + def setUp(self): + self.gh = api.Github() + self.handler = self.gh.users + + def test_set_username(self): + handler = self.handler.set_username('test') + self.assertEquals(id(handler), id(self.handler)) + self.assertEquals(handler.username, 'test') + model_user = Mock() + model_user.login = 'test' + handler = self.handler.set_username(model_user) + self.assertEquals(handler.username, 'test') + + def test_parse_user(self): + model_user = Mock() + model_user.login = 'test' + self.assertRaises(UserIsAnonymous, self.handler._parse_user, None) + user = self.handler._parse_user(model_user) + self.assertEquals(user, 'test') + user = self.handler._parse_user('test') + self.assertEquals(user, 'test') + self.assertRaises(UserIsAnonymous, self.handler._parse_user, Mock()) + self.handler.set_username('octocat') + self.assertEquals('octocat', self.handler._parse_user(None)) + self.assertEquals('octocat', self.handler._parse_user(Mock())) + self.assertEquals('test', self.handler._parse_user('test')) + self.assertEquals('test', self.handler._parse_user(model_user)) + + @patch.object(api.Github, 'get') + def test_get(self, get): + get.return_value = GET_USER + self.assertRaises(UserIsAnonymous, self.handler.get) + user = self.handler.get('octocat') + self.assertIsInstance(user, User) + get.assert_called_with('users/octocat') + + @patch.object(api.Github, '_request') + def test_get_followers(self, request): + response = request.return_value + response.headers = {'link': GET_LINK} + response.content = self.gh._parser.dumps(GET_SHORT_USERS) # 2 users + followers = list(self.handler.get_followers('test')) + request.assert_called_with('GET', 'users/test/followers', page=5) + self.assertIsInstance(followers[0], User) + self.assertEquals(len(followers), 10) + followers = list(self.handler.get_followers('test', limit=2)) + self.assertEquals(len(followers), 2) + self.assertEquals(followers[0].login, 'octocat') + + @patch.object(api.Github, '_request') + def test_get_following(self, request): + response = request.return_value + response.headers = {'link': GET_LINK} + response.content = self.gh._parser.dumps(GET_SHORT_USERS) # 2 users + following = list(self.handler.get_following('test')) + request.assert_called_with('GET', 'users/test/following', page=5) + self.assertIsInstance(following[0], User) + self.assertEquals(len(following), 10) + following = list(self.handler.get_following('test', limit=2)) + self.assertEquals(len(following), 2) + + @patch.object(api.Github, '_request') + def test_get_repos(self, request): + response = request.return_value + response.headers = {'link': GET_LINK} + response.content = self.gh._parser.dumps(GET_SHORT_REPOS) # 1 repo + repos = list(self.handler.get_repos('test')) + request.assert_called_with('GET', 'users/test/repos', page=5) + self.assertIsInstance(repos[0], Repo) + self.assertEquals(len(repos), 5) + repos = list(self.handler.get_repos('test', limit=2)) + self.assertEquals(len(repos), 2) + self.assertIsInstance(repos[0].owner, User) + + @patch.object(api.Github, '_request') + def test_get_watched(self, request): + response = request.return_value + response.headers = {'link': GET_LINK} + response.content = self.gh._parser.dumps(GET_SHORT_REPOS) # 1 repo + watched = list(self.handler.get_watched('test')) + request.assert_called_with('GET', 'users/test/watched', page=5) + self.assertIsInstance(watched[0], Repo) + self.assertEquals(len(watched), 5) + watched = list(self.handler.get_watched('test', limit=2)) + self.assertEquals(len(watched), 2) + + @patch.object(api.Github, '_request') + def test_get_orgs(self, request): + response = request.return_value + response.headers = {'link': GET_LINK} + response.content = self.gh._parser.dumps(GET_SHORT_ORGS) # 1 repo + orgs = list(self.handler.get_orgs('test')) + request.assert_called_with('GET', 'users/test/orgs', page=5) + self.assertIsInstance(orgs[0], Org) + self.assertEquals(len(orgs), 5) + orgs = list(self.handler.get_orgs('test', limit=2)) + self.assertEquals(len(orgs), 2) + self.assertEquals(orgs[0].login, 'github') + + @patch.object(api.Github, '_request') + def test_get_gists(self, request): + response = request.return_value + response.headers = {'link': GET_LINK} + response.content = self.gh._parser.dumps(GET_SHORT_GISTS) # 1 repo + gists = list(self.handler.get_gists('test')) + request.assert_called_with('GET', 'users/test/gists', page=5) + self.assertIsInstance(gists[0], Gist) + self.assertEquals(len(gists), 5) + gists = list(self.handler.get_gists('test', limit=2)) + self.assertEquals(len(gists), 2) + self.assertIsInstance(gists[0].files, dict) + from github3.models.gists import File + self.assertIsInstance(gists[0].files['ring.erl'], File) |