Added first tests

.travis.yml

@@ -7,7 +7,12 @@ python:
 before_install:
   - pip install -U pip
   - pip install -U wheel setuptools flake8
+  - pip install codecov
 install:
   - python setup.py -q install
 script:
-  - flake8 ./src
+  - flake8 ./src ./tests
+  - python setup.py test --addopts "--cov=./src/dynamic_fixtures"
+
+after_success:
+  - codecov

setup.cfg

@@ -7,3 +7,5 @@ tag = True
 
 [bumpversion:file:docs/conf.py]
 
+[aliases]
+test = pytest

src/keycloak/client.py

@@ -3,7 +3,7 @@
 try:
     from urllib.parse import urljoin  # noqa: F401
 except ImportError:
-    from urllib import urlencode  # noqa: F401
+    from urlparse import urljoin  # noqa: F401
 
 import requests
 

tests/keycloak/test_client.py

@@ -0,0 +1,157 @@
+import mock
+
+from unittest import TestCase
+from requests import Session
+
+from keycloak.client import KeycloakClient
+
+
+class KeycloakClientTestCase(TestCase):
+
+    def setUp(self):
+        self.headers = {'initial': 'header'}
+        self.server_url = 'https://example.com'
+
+        self.client = KeycloakClient(server_url=self.server_url,
+                                     headers=self.headers)
+
+    def test_session(self):
+        """
+        Case: Session get requested
+        Expected: Session object get returned and the same one if called for
+                  the second time
+        """
+        session = self.client.session
+
+        self.assertIsInstance(session, Session)
+
+        self.assertEqual(session, self.client.session)
+
+    def test_get_full_url(self):
+        """
+        Case: retrieve a valid url
+        Expected: The path get added to the base url or to the given url
+        """
+
+        self.assertEqual(self.client.get_full_url('/some/path'),
+                         'https://example.com/some/path')
+
+        self.assertEqual(self.client.get_full_url('/some/path',
+                                                  'https://another_url.com'),
+                         'https://another_url.com/some/path')
+
+    @mock.patch('keycloak.client.requests', autospec=True)
+    def test_post(self, request_mock):
+        """
+        Case: A POST request get executed
+        Expected: The correct parameters get given to the request library
+        """
+        request_mock.Session.return_value.headers = mock.MagicMock()
+
+        self.client._handle_response = mock.MagicMock()
+        response = self.client.post(url='https://example.com/test',
+                                    data={'some': 'data'},
+                                    headers={'some': 'header'},
+                                    extra='param')
+
+        request_mock.Session.return_value.post.assert_called_once_with(
+            'https://example.com/test',
+            data={'some': 'data'},
+            headers={'some': 'header'},
+            params={'extra': 'param'}
+        )
+        self.client._handle_response.assert_called_once_with(
+            request_mock.Session.return_value.post.return_value
+        )
+        self.assertEqual(response, self.client._handle_response.return_value)
+
+    @mock.patch('keycloak.client.requests', autospec=True)
+    def test_get(self, request_mock):
+        """
+        Case: A GET request get executed
+        Expected: The correct parameters get given to the request library
+        """
+        request_mock.Session.return_value.headers = mock.MagicMock()
+
+        self.client._handle_response = mock.MagicMock()
+        response = self.client.get(url='https://example.com/test',
+                                   headers={'some': 'header'},
+                                   extra='param')
+
+        request_mock.Session.return_value.get.assert_called_once_with(
+            'https://example.com/test',
+            headers={'some': 'header'},
+            params={'extra': 'param'}
+        )
+
+        self.client._handle_response.assert_called_once_with(
+            request_mock.Session.return_value.get.return_value
+        )
+        self.assertEqual(response, self.client._handle_response.return_value)
+
+    @mock.patch('keycloak.client.requests', autospec=True)
+    def test_put(self, request_mock):
+        """
+        Case: A PUT request get executed
+        Expected: The correct parameters get given to the request library
+        """
+        request_mock.Session.return_value.headers = mock.MagicMock()
+
+        self.client._handle_response = mock.MagicMock()
+        response = self.client.put(url='https://example.com/test',
+                                   data={'some': 'data'},
+                                   headers={'some': 'header'},
+                                   extra='param')
+
+        request_mock.Session.return_value.put.assert_called_once_with(
+            'https://example.com/test',
+            data={'some': 'data'},
+            headers={'some': 'header'},
+            params={'extra': 'param'}
+        )
+
+        self.client._handle_response.assert_called_once_with(
+            request_mock.Session.return_value.put.return_value
+        )
+        self.assertEqual(response,
+                         self.client._handle_response.return_value)
+
+    @mock.patch('keycloak.client.requests', autospec=True)
+    def test_delete(self, request_mock):
+        """
+        Case: A DELETE request get executed
+        Expected: The correct parameters get given to the request library
+        """
+        request_mock.Session.return_value.headers = mock.MagicMock()
+
+        self.client._handle_response = mock.MagicMock()
+        response = self.client.delete(url='https://example.com/test',
+                                      headers={'some': 'header'},
+                                      extra='param')
+
+        request_mock.Session.return_value.delete.assert_called_once_with(
+            'https://example.com/test',
+            headers={'some': 'header'},
+            extra='param'
+        )
+        self.assertEqual(response,
+                         request_mock.Session.return_value.delete.return_value)
+
+    def test_handle_response(self):
+        """
+        Case: Response get processed
+        Expected: Decoded json get returned else raw_response
+        """
+        response = mock.MagicMock()
+
+        processed_response = self.client._handle_response(response=response)
+
+        response.raise_for_status.assert_called_once_with()
+        response.json.assert_called_once_with()
+
+        self.assertEqual(processed_response, response.json.return_value)
+
+        response.json.side_effect = ValueError
+        processed_response = self.client._handle_response(response=response)
+
+        self.assertEqual(processed_response, response.content)

tests/keycloak/test_realm.py

@@ -0,0 +1,80 @@
+from unittest import TestCase
+
+import mock
+
+from keycloak.admin import KeycloakAdmin
+from keycloak.authz import KeycloakAuthz
+from keycloak.client import KeycloakClient
+from keycloak.openid_connect import KeycloakOpenidConnect
+from keycloak.realm import KeycloakRealm
+
+
+class KeycloakRealmTestCase(TestCase):
+
+    def setUp(self):
+        self.realm = KeycloakRealm('https://example.com', 'some-realm',
+                                   headers={'some': 'header'})
+
+    def test_instance(self):
+        """
+        Case: Realm is instantiated
+        Expected: Name and server_url are exposed
+        """
+        self.assertEqual(self.realm.realm_name, 'some-realm')
+        self.assertEqual(self.realm.server_url, 'https://example.com')
+
+    @mock.patch('keycloak.realm.KeycloakClient', autospec=True)
+    def test_client(self, mocked_client):
+        """
+        Case: Client get requested
+        Expected: Client get returned and the second time the same get returned
+        """
+        client = self.realm.client
+
+        self.assertIsInstance(client, KeycloakClient)
+
+        self.assertEqual(client, self.realm.client)
+
+        mocked_client.assert_called_once_with(server_url='https://example.com',
+                                              headers={'some': 'header'})
+
+    @mock.patch('keycloak.realm.KeycloakOpenidConnect', autospec=True)
+    def test_openid_connect(self, mocked_openid_client):
+        """
+        Case: OpenID client get requested
+        Expected: OpenID client get returned
+        """
+        openid_client = self.realm.open_id_connect(
+            client_id='client-id',
+            client_secret='client-secret'
+        )
+
+        self.assertIsInstance(openid_client, KeycloakOpenidConnect)
+        self.assertEqual(openid_client, mocked_openid_client.return_value)
+        mocked_openid_client.assert_called_once_with(
+            realm=self.realm,
+            client_id='client-id',
+            client_secret='client-secret'
+        )
+
+    @mock.patch('keycloak.realm.KeycloakAdmin', autospec=True)
+    def test_admin(self, mocked_admin_client):
+        """
+        Case: Admin client get requested
+        Expected: Admin client get returned
+        """
+        admin_client = self.realm.admin
+        self.assertIsInstance(admin_client, KeycloakAdmin)
+        mocked_admin_client.assert_called_once_with(realm=self.realm)
+
+    @mock.patch('keycloak.realm.KeycloakAuthz', autospec=True)
+    def test_authz(self, mocked_authz_client):
+        """
+        Case: Authz client get requested
+        Expected: Authz client get returned
+        """
+        authz_client = self.realm.authz(client_id='client-id')
+
+        self.assertIsInstance(authz_client, KeycloakAuthz)
+        mocked_authz_client.assert_called_once_with(realm=self.realm,
+                                                    client_id='client-id')