Core tests

core.client
core.result

5 files changed, 212 insertions, 3 deletions

diff --git a/pygithub3/tests/core/__init__.py b/pygithub3/tests/core/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pygithub3/tests/core/__init__.py
diff --git a/pygithub3/tests/core/test_client.py b/pygithub3/tests/core/test_client.py
new file mode 100644
index 0000000..57051e2
--- /dev/null
+++ b/pygithub3/tests/core/test_client.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+from unittest import TestCase
+
+import requests
+from pygithub3.core.client import Client
+from pygithub3.exceptions import *
+from mock import patch
+
+
+class TestClient(TestCase):
+
+    def setUp(self):
+        self.c = Client()
+
+    def test_set_credentials_with_valid(self):
+        self.c.set_credentials('login', 'password')
+        self.assertEqual(self.c.requester.auth, ('login', 'password'))
+
+    def test_set_credentials_with_invalid(self):
+        self.c.set_credentials('', '')
+        self.assertIsNone(self.c.requester.auth)
+
+    def test_set_token_with_valid(self):
+        self.c.set_token('tokenize')
+        self.assertEqual(self.c.requester.params['access_token'], 'tokenize')
+
+    def test_set_token_with_invalid(self):
+        self.c.set_token('')
+        self.assertIsNone(self.c.requester.params.get('access_token'))
+
+    def test_INIT_client_with_another_config_args(self):
+        new_c = Client(base_url='url', per_page=10, user='me', repo='myrepo',
+                       verbose='stream')
+        self.assertEqual(new_c.config['base_url'], 'url')
+        self.assertEqual(new_c.requester.params['per_page'], 10)
+        self.assertEqual(new_c.user, 'me')
+        self.assertEqual(new_c.repo, 'myrepo')
+        self.assertEqual(new_c.requester.config['verbose'], 'stream')
+
+    @patch.object(requests.sessions.Session, 'request')
+    def test_PARSE_args_in_request_without_params(self, request_method):
+        extra = dict(arg1='arg1', arg2='arg2')
+        self.c.request('', '', data='data', **extra)
+        request_method.assert_called_with('', self.c.config['base_url'],
+            data='data', params=extra)
+
+    @patch.object(requests.sessions.Session, 'request')
+    def test_PARSE_args_in_request_with_params(self, request_method):
+        extra = dict(arg1='arg1', arg2='arg2')
+        self.c.request('', '', params=dict(arg0='arg0'), **extra)
+        request_method.assert_called_with('', self.c.config['base_url'],
+            params=dict(arg0='arg0', **extra))
+
+    @patch.object(Client, 'request')
+    def test_DELEGATES_methods(self, request_method):
+        self.c.get('')
+        request_method.assert_called_with('get', '')
+        self.c.post('')
+        request_method.assert_called_with('post', '')
+        self.c.patch('')
+        request_method.assert_called_with('patch', '')
+        self.c.put('')
+        request_method.assert_called_with('put', '')
+        self.c.delete('')
+        request_method.assert_called_with('delete', '')
+        self.c.head('')
+        request_method.assert_called_with('head', '')
+
+
+@patch.object(requests.sessions.Session, 'request')
+class TestClientRaises(TestCase):
+
+    def setUp(self):
+        self.c = Client()
+        self.callback = (self.c.request, 'method', 'request')
+
+    def test_raise_NotFound(self, request_method):
+        request_method.return_value.status_code = 404
+        self.assertRaises(NotFound, *self.callback)
+
+    def test_raise_BadRequest(self, request_method):
+        request_method.return_value.status_code = 400
+        self.assertRaises(BadRequest, *self.callback)
+
+    def test_raise_UnprocessableEntity(self, request_method):
+        request_method.return_value.status_code = 422
+        self.assertRaises(UnprocessableEntity, *self.callback)
diff --git a/pygithub3/tests/core/test_result.py b/pygithub3/tests/core/test_result.py
new file mode 100644
index 0000000..4a3a7f5
--- /dev/null
+++ b/pygithub3/tests/core/test_result.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+from unittest import TestCase
+
+from mock import Mock
+
+from pygithub3.core.client import Client
+from pygithub3.core.result import Result, Page
+from .utils import (mock_paginate_github_in_GET,
+                    mock_no_paginate_github_in_GET, request)
+
+
+class ResultInitMixin(object):
+
+    def setUp(self):
+        self.c = Client()
+        self.get_request = Mock(side_effect=self.mock)
+        self.resource_loads = request.resource.loads
+        self.c.get = self.get_request
+        self.r = Result(self.c, request)
+
+    def tearDown(self):
+        self.resource_loads.reset_mock()  # It mocks class method
+
+class TestResultWithPaginate(ResultInitMixin, TestCase):
+
+    @property
+    def mock(self):
+        return mock_paginate_github_in_GET
+
+    def test_iteration_CALLS(self):
+        self.assertEqual(self.get_request.call_count, 0)
+        self.assertEqual(self.resource_loads.call_count, 0)
+        list(self.r)
+        self.get_request.assert_called_once_with(request, page=1)
+
+    def test_consumed_are_Pages(self):
+        pages_that_are_Pages = len(
+            filter(lambda page: isinstance(page, Page), list(self.r)))
+        self.assertEqual(pages_that_are_Pages, 3, 'There are not 3 Pages objs')
+        self.assertEqual(self.resource_loads.call_count, 1)
+
+    def test_all_iteration_CALLS(self):
+        self.r.all()
+        self.assertEqual(self.get_request.call_count, 3)
+        self.assertEqual(self.resource_loads.call_count, 3)
+
+    def test_CACHE_with_renew_iterations(self):
+        self.r.all()
+        self.r.all()
+        self.assertEqual(self.get_request.call_count, 3)
+        self.assertEqual(len(self.r.getter.cache), 3)
+        self.assertEqual(self.resource_loads.call_count, 3)
+
+    def test_ITERATOR_calls(self):
+        self.r.iterator()
+        self.assertEqual(self.get_request.call_count, 0)
+        self.assertEqual(self.resource_loads.call_count, 0)
+
+
+class TestResultWithoutPaginate(ResultInitMixin, TestCase):
+
+    @property
+    def mock(self):
+        return mock_no_paginate_github_in_GET
+
+    def test_iteration_stop_at_1(self):
+        self.r.next()
+        self.assertRaises(StopIteration, self.r.next)
+
+    def test_get_only_1page(self):
+        self.r.all()
+        self.assertEqual(self.get_request.call_count, 1)
+        self.assertEqual(self.resource_loads.call_count, 1)
diff --git a/pygithub3/tests/core/utils.py b/pygithub3/tests/core/utils.py
new file mode 100644
index 0000000..e77ef20
--- /dev/null
+++ b/pygithub3/tests/core/utils.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+from mock import Mock
+
+from pygithub3.resources.base import Resource
+from pygithub3.requests import Request
+
+
+class DummyResource(Resource):
+    pass
+
+
+def loads_mock(content):
+    return content
+DummyResource.loads = Mock(side_effect=loads_mock)
+
+
+class DummyRequest(Request):
+    uri = 'dummyrequest'
+    resource = DummyResource
+
+
+request = DummyRequest({})
+# Working without json but name it json-related to not confuse
+json_content = [dict(name='dummy')]
+
+
+def mock_paginate_github_in_GET(request, page):
+    def header(page):
+        return {'link': '<https://d.com/d?page=%s>; rel="last"' % page}
+
+    def content(page):
+        if page >= 3:
+            return json_content
+        return json_content * 2
+
+    response = Mock()
+    response.headers = header(3)
+    response.content = content(page)
+    return response
+
+
+def mock_no_paginate_github_in_GET(request, page):
+    response = Mock()
+    response.headers = {}
+    response.content = [json_content * 3]
+    return response
diff --git a/pygithub3/tests/test_errors.py b/pygithub3/tests/test_errors.py
deleted file mode 100644
index aee3da5..0000000
--- a/pygithub3/tests/test_errors.py
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-# -*- encoding: utf-8 -*-
-