From 78752f56adb57bb1d5672a6ac819944477b7b529 Mon Sep 17 00:00:00 2001 From: David Medina Date: Sun, 13 Nov 2011 19:29:12 +0100 Subject: Testing on fire (handlers, user_handler) Also fix bugs, pep8 --- github3/tests/user_handler_test.py | 58 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 github3/tests/user_handler_test.py (limited to 'github3/tests/user_handler_test.py') diff --git a/github3/tests/user_handler_test.py b/github3/tests/user_handler_test.py new file mode 100644 index 0000000..9eb3708 --- /dev/null +++ b/github3/tests/user_handler_test.py @@ -0,0 +1,58 @@ +#!/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.user import User, AuthUser +from github3.exceptions import * + + +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} # 5 pages + response.content = self.gh._parser.dumps(GET_FOLLOWERS) + followers = list(self.handler.get_followers('test')) + self.assertIsInstance(followers[0], User) + pass -- cgit v1.2.3-59-g8ed1b From 0664d60525f03ba5cbeee080b3d69a4f79bd249a Mon Sep 17 00:00:00 2001 From: David Medina Date: Mon, 14 Nov 2011 00:46:46 +0100 Subject: Complete anonymous User handler test --- github3/tests/fixtures.py | 71 +++++++++++++++++++++++++++++++- github3/tests/user_handler_test.py | 84 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 149 insertions(+), 6 deletions(-) (limited to 'github3/tests/user_handler_test.py') diff --git a/github3/tests/fixtures.py b/github3/tests/fixtures.py index fdbc3fb..469b00a 100644 --- a/github3/tests/fixtures.py +++ b/github3/tests/fixtures.py @@ -22,12 +22,13 @@ GET_USER = { "type": "User" } -GET_LINK = '; rel="next", ; rel="last"' +GET_LINK = '; rel="next", \ +; rel="last"' GET_RESOURCES = [ {'login': 'octocat'}, {'login': 'octocat'} ] -GET_FOLLOWERS = [ +GET_SHORT_USERS = [ { "login": "octocat", "id": 1, @@ -41,3 +42,69 @@ GET_FOLLOWERS = [ "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", + "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", + "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" + } +] diff --git a/github3/tests/user_handler_test.py b/github3/tests/user_handler_test.py index 9eb3708..ef57925 100644 --- a/github3/tests/user_handler_test.py +++ b/github3/tests/user_handler_test.py @@ -5,10 +5,17 @@ from unittest import TestCase from mock import Mock, patch from github3 import api from fixtures import * -from github3.models.user import User, AuthUser +from github3.models import User, AuthUser, Repo, Gist, Org from github3.exceptions import * +class TestAuthUserHandler(TestCase): + """ Test private api about user logged """ + + def setUp(self): + pass + + class TestUserHandler(TestCase): """ Test public api about users """ @@ -51,8 +58,77 @@ class TestUserHandler(TestCase): @patch.object(api.Github, '_request') def test_get_followers(self, request): response = request.return_value - response.headers = {'link': GET_LINK} # 5 pages - response.content = self.gh._parser.dumps(GET_FOLLOWERS) + 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) - pass + 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) -- cgit v1.2.3-59-g8ed1b From 437b7a6b9623bc4670de3c2e370d671ced0bc5c8 Mon Sep 17 00:00:00 2001 From: David Medina Date: Wed, 16 Nov 2011 01:55:57 +0100 Subject: Wip on AuthUser handler tests Also "python way" with Design by contract --- github3/handlers/base.py | 2 +- github3/handlers/users.py | 5 ++--- github3/tests/fixtures.py | 36 ++++++++++++++++++++++++++++++++++++ github3/tests/user_handler_test.py | 34 +++++++++++++++++++++++++++++++++- 4 files changed, 72 insertions(+), 5 deletions(-) (limited to 'github3/tests/user_handler_test.py') diff --git a/github3/handlers/base.py b/github3/handlers/base.py index c27b80c..0b3fa8a 100644 --- a/github3/handlers/base.py +++ b/github3/handlers/base.py @@ -15,7 +15,7 @@ class Handler(object): def _prefix_resource(self, resource): prefix = getattr(self, 'prefix', '') - return '/'.join((prefix, resource)).strip('/') + return '/'.join((prefix, str(resource))).strip('/') def _get_converter(self, **kwargs): converter = kwargs.get( diff --git a/github3/handlers/users.py b/github3/handlers/users.py index 0b84107..84180b5 100644 --- a/github3/handlers/users.py +++ b/github3/handlers/users.py @@ -166,10 +166,9 @@ class AuthUser(User): :param `user`: User model or username string - NOTE: Maybe bug in API, return text/html. Waitingf for answer """ - parse_user = str(getattr(user, 'login', user)) + parse_user = getattr(user, 'login', user) return self._put('following/%s' % parse_user) def unfollow(self, user): @@ -179,7 +178,7 @@ class AuthUser(User): :param `user`: User model or username string """ - parse_user = str(getattr(user, 'login', user)) + parse_user = getattr(user, 'login', user) return self._delete('following/%s' % parse_user) def get_keys(self): diff --git a/github3/tests/fixtures.py b/github3/tests/fixtures.py index 02086f8..5f56753 100644 --- a/github3/tests/fixtures.py +++ b/github3/tests/fixtures.py @@ -117,3 +117,39 @@ GET_SHORT_GISTS = [ "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" +] diff --git a/github3/tests/user_handler_test.py b/github3/tests/user_handler_test.py index ef57925..b1fd0d0 100644 --- a/github3/tests/user_handler_test.py +++ b/github3/tests/user_handler_test.py @@ -13,8 +13,40 @@ class TestAuthUserHandler(TestCase): """ Test private api about user logged """ def setUp(self): - pass + self.gh = api.Github('test', 'pass') + self.handler = self.gh.users + @patch.object(api.Github, 'get') + def test_get(self, get): + get.return_value = GET_FULL_USER + user = self.handler.get() + self.assertIsInstance(user, AuthUser) + get.assert_called_with('user') + self.assertEquals(len(user), len(GET_FULL_USER)) + + @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) class TestUserHandler(TestCase): """ Test public api about users """ -- cgit v1.2.3-59-g8ed1b From 357985782664eba287e73e5bbbb28c1884adccea Mon Sep 17 00:00:00 2001 From: David Medina Date: Thu, 17 Nov 2011 00:17:48 +0100 Subject: Complete AuthUser handler test Update code putting tests in green --- github3/handlers/users.py | 46 +++++++++----- github3/models/user.py | 11 ++-- github3/tests/fixtures.py | 13 +++- github3/tests/user_handler_test.py | 121 ++++++++++++++++++++++++++++++++++++- 4 files changed, 167 insertions(+), 24 deletions(-) (limited to 'github3/tests/user_handler_test.py') diff --git a/github3/handlers/users.py b/github3/handlers/users.py index 34ed013..08c6171 100644 --- a/github3/handlers/users.py +++ b/github3/handlers/users.py @@ -155,7 +155,7 @@ class AuthUser(User): :param `user`: User model or username string """ - parse_user = str(getattr(user, 'login', user)) + parse_user = getattr(user, 'login', user) return self._bool('following/%s' % parse_user) def follow(self, user): @@ -179,23 +179,28 @@ class AuthUser(User): parse_user = getattr(user, 'login', user) return self._delete('following/%s' % parse_user) - def get_keys(self): + def get_keys(self, limit=None): """ Get public keys """ return self._get_resources('keys', model=models.Key, limit=limit) - def get_key(self, key_id): - """ Get public key by id """ + def get_key(self, key): + """ Get public key + + :param `key`: Key model or key id + + """ - return self._get_resource('keys/%s' % key_id, model=models.Key) + parse_key_id = getattr(key, 'id', key) + return self._get_resource('keys/%s' % parse_key_id, model=models.Key) def create_key(self, **kwargs): """ Create public key :param title - :param key: Key string + :param key: Key string (It must starts with 'ssh-rsa') """ #TODO: render key.pub file @@ -205,12 +210,17 @@ class AuthUser(User): } return self._post_resource('keys', data=key, model=models.Key) - def delete_key(self, key_id): - """ Delete public key """ + def delete_key(self, key): + """ Delete public key - return self._delete('keys/%s' % key_id) + :param `key`: Key model or key id - def get_repos(self, filter='all'): + """ + + parse_key_id = getattr(key, 'id', key) + return self._delete('keys/%s' % parse_key_id) + + def get_repos(self, filter='all', limit=None): """ Return user's public repositories @@ -224,8 +234,8 @@ class AuthUser(User): """ Return true if you are watching the user repository - :param owner: username - :param repo: repository name + :param owner: Model user or username string + :param repo: Model repo or repo name string is_watching_repo('copitux', 'python-github3') """ @@ -237,18 +247,22 @@ class AuthUser(User): """ Watch the repository - :param owner: username - :param repo: repository name + :param owner: Model user or username string + :param repo: Model repo or repo name string """ + owner = getattr(owner, 'login', owner) + repo = getattr(repo, 'name', repo) return self._put('watched/%s/%s' % (owner, repo)) def unwatch_repo(self, owner, repo): """ Unwatch the repository - :param owner: username - :param repo: repository name + :param owner: Model user or username string + :param repo: Model repo or repo name string """ + owner = getattr(owner, 'login', owner) + repo = getattr(repo, 'name', repo) return self._delete('watched/%s/%s' % (owner, repo)) diff --git a/github3/models/user.py b/github3/models/user.py index 93201bd..aed6f09 100644 --- a/github3/models/user.py +++ b/github3/models/user.py @@ -52,17 +52,18 @@ class User(BaseResource): } def __repr__(self): - return '' % self.login + return '' % getattr(self, 'login', 'without user') #def handler(self): - # return self._gh.user_handler(self.login, force=True) + # return self._gh.users class AuthUser(User): """Github Authenticated User object model.""" - #def handler(self): - # return self._gh.user_handler(self.login, force=True, private=True) - def __repr__(self): return '' % self.login + + #def handler(self): + # return self._gh.users + diff --git a/github3/tests/fixtures.py b/github3/tests/fixtures.py index 5f56753..ff5179c 100644 --- a/github3/tests/fixtures.py +++ b/github3/tests/fixtures.py @@ -23,8 +23,8 @@ GET_USER = { "type": "User" } -GET_LINK = '; rel="next", \ -; rel="last"' +GET_LINK = '; rel="next", \ +; rel="last"' GET_RESOURCES = [ {'login': 'octocat'}, @@ -153,3 +153,12 @@ 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/user_handler_test.py b/github3/tests/user_handler_test.py index b1fd0d0..28fda3b 100644 --- a/github3/tests/user_handler_test.py +++ b/github3/tests/user_handler_test.py @@ -5,7 +5,7 @@ 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 +from github3.models import User, AuthUser, Repo, Gist, Org, Key from github3.exceptions import * @@ -15,6 +15,8 @@ class TestAuthUserHandler(TestCase): def setUp(self): self.gh = api.Github('test', 'pass') self.handler = self.gh.users + self.user_mock = Mock() + self.user_mock.login = 'user_model' @patch.object(api.Github, 'get') def test_get(self, get): @@ -48,6 +50,123 @@ class TestAuthUserHandler(TestCase): 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_get_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.get_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.get_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 """ -- cgit v1.2.3-59-g8ed1b From ba0ce2dc98c2d72852a10ece61d5611fdfdbf66d Mon Sep 17 00:00:00 2001 From: David Medina Date: Sun, 27 Nov 2011 13:20:06 +0100 Subject: Diff between 'my' and 'get' --- github3/handlers/users.py | 37 ++++++++++++++++++++++++--- github3/tests/user_handler_test.py | 51 ++++++++++++++++++++++++++++++++++---- 2 files changed, 80 insertions(+), 8 deletions(-) (limited to 'github3/tests/user_handler_test.py') diff --git a/github3/handlers/users.py b/github3/handlers/users.py index 4a181c8..ec40f02 100644 --- a/github3/handlers/users.py +++ b/github3/handlers/users.py @@ -108,17 +108,35 @@ class User(Handler): limit=limit) -class AuthUser(User): +class AuthUser(Handler): """ User handler with public and private access """ prefix = 'user' + def __init__(self, gh): + super(AuthUser, self).__init__(gh) + self._inject_handler(User(gh), prefix='get') + def __repr__(self): return ' %s>' % self._gh.session.auth[0] - def get(self): + def me(self): + """ Return authenticated user """ + return self._get_resource('', model=models.AuthUser) + def my_followers(self, limit=None): + """ Return authenticated user followers """ + + return self._get_resources('followers', model=models.User, + limit=limit) + + def my_following(self, limit=None): + """ Return authenticated user following """ + + return self._get_resources('following', model=models.User, + limit=limit) + def get_emails(self): """ Return list of emails """ @@ -220,7 +238,7 @@ class AuthUser(User): parse_key_id = getattr(key, 'id', key) return self._delete('keys/%s' % parse_key_id) - def get_repos(self, filter='all', limit=None): + def my_repos(self, filter='all', limit=None): """ Return user's public repositories @@ -230,6 +248,12 @@ class AuthUser(User): return self._get_resources('repos', model=models.Repo, limit=limit, type=str(filter)) + def my_watched(self, limit=None): + """ Return authenticated user repos that he watch """ + + return self._get_resources('watched', model=models.Repo, + limit=limit) + def is_watching_repo(self, owner, repo): """ Return true if you are watching the user repository @@ -266,3 +290,10 @@ class AuthUser(User): owner = getattr(owner, 'login', owner) repo = getattr(repo, 'name', repo) return self._delete('watched/%s/%s' % (owner, repo)) + + def my_orgs(self, limit=None): + """ List public and private organizations + for the authenticated user + """ + + return self._get_resources('orgs', model=models.Org, limit=limit) diff --git a/github3/tests/user_handler_test.py b/github3/tests/user_handler_test.py index 28fda3b..33658d2 100644 --- a/github3/tests/user_handler_test.py +++ b/github3/tests/user_handler_test.py @@ -7,6 +7,7 @@ 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): @@ -18,14 +19,54 @@ class TestAuthUserHandler(TestCase): 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_get(self, get): + def test_me(self, get): get.return_value = GET_FULL_USER - user = self.handler.get() + 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 @@ -117,17 +158,17 @@ class TestAuthUserHandler(TestCase): delete.assert_called_with('user/keys/1', method='delete') @patch.object(api.Github, '_request') - def test_get_repos(self, 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.get_repos(filter='public')) + 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.get_repos(limit=2)) + repos = list(self.handler.my_repos(limit=2)) self.assertEquals(len(repos), 2) @patch.object(api.Github, 'head') -- cgit v1.2.3-59-g8ed1b