[WIP] Making it possible to add custom options

.github/workflows/unittest.yaml

@@ -0,0 +1,30 @@
+name: Python Unit Test
+
+on: [push]
+
+jobs:
+  build:
+    name: GitHub Action for Pytest
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest
+          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+
+      - name: Test with unittest
+        run: |
+          pytest ./odata/tests

odata/connection.py

@@ -24,7 +24,6 @@ def inner(*args, **kwargs):
 class ODataConnection(object):
 
     base_headers = {
-        'Accept': 'application/json',
         'OData-Version': '4.0',
         'User-Agent': 'python-odata {0}'.format(version),
     }
@@ -38,6 +37,9 @@ def __init__(self, session=None, auth=None):
         self.auth = auth
         self.log = logging.getLogger('odata.connection')
 
+    def __del__(self):
+        self.session.close()
+
     def _apply_options(self, kwargs):
         kwargs['timeout'] = self.timeout
 
@@ -75,6 +77,7 @@ def _handle_odata_error(self, response):
             response_ct = response.headers.get('content-type', '')
 
             if 'application/json' in response_ct:
+                self.log.debug(u'JSON: {0}'.format(response.json()))
                 errordata = response.json()
 
                 if 'error' in errordata:
@@ -88,6 +91,9 @@ def _handle_odata_error(self, response):
                         ie = odata_error['innererror']
                         detailed_message = ie.get('message') or detailed_message
 
+            response.close()
+            self.log.info(u'Closed response on failure with HTTP status {0}'.format(code))
+
             msg = ' | '.join([status_code, code, message, detailed_message])
             err = ODataError(msg)
             err.status_code = status_code
@@ -97,64 +103,104 @@ def _handle_odata_error(self, response):
             raise err
 
     def execute_get(self, url, params=None):
-        headers = {}
-        headers.update(self.base_headers)
-
-        self.log.info(u'GET {0}'.format(url))
-        if params:
-            self.log.info(u'Query: {0}'.format(params))
-
-        response = self._do_get(url, params=params, headers=headers)
-        self._handle_odata_error(response)
-        response_ct = response.headers.get('content-type', '')
-        if response.status_code == requests.codes.no_content:
-            return
-        if 'application/json' in response_ct:
-            data = response.json()
-            return data
-        else:
-            msg = u'Unsupported response Content-Type: {0}'.format(response_ct)
-            raise ODataError(msg)
+        try:
+            response = None
+            headers = {}
+            headers.update(self.base_headers)
+
+            self.log.info(u'GET {0}'.format(url))
+            if params:
+                self.log.info(u'Query: {0}'.format(params))
+
+            response = self._do_get(url, params=params, headers=headers)
+            self._handle_odata_error(response)
+            response_ct = response.headers.get('content-type', '')
+            if response.status_code == requests.codes.no_content:
+                return
+            if 'application/json' in response_ct:
+                self.log.debug(u'JSON: {0}'.format(response.json()))
+                return response.json()
+            else:
+                msg = u'Unsupported response Content-Type: {0}'.format(response_ct)
+                raise ODataError(msg)
+        except:
+            raise
+        finally:
+            if response:
+                response.close()
+                self.log.info(u'Closed GET response for {0}'.format(url))
 
     def execute_post(self, url, data, params=None):
-        headers = {
-            'Content-Type': 'application/json',
-        }
-        headers.update(self.base_headers)
+        try:
+            response = None
+            headers = {
+                'Content-Type': 'application/json',
+            }
+            headers.update(self.base_headers)
 
-        data = json.dumps(data)
+            data = json.dumps(data)
 
-        self.log.info(u'POST {0}'.format(url))
-        self.log.info(u'Payload: {0}'.format(data))
+            self.log.info(u'POST {0}'.format(url))
+            self.log.info(u'Payload: {0}'.format(data))
 
-        response = self._do_post(url, data=data, headers=headers, params=params)
-        self._handle_odata_error(response)
-        response_ct = response.headers.get('content-type', '')
-        if response.status_code == requests.codes.no_content:
-            return
-        if 'application/json' in response_ct:
-            return response.json()
-        # no exceptions here, POSTing to Actions may not return data
+            response = self._do_post(url, data=data, headers=headers, params=params)
+            self._handle_odata_error(response)
+            response_ct = response.headers.get('content-type', '')
+            if response.status_code == requests.codes.no_content:
+                return
+            if 'application/json' in response_ct:
+                self.log.debug(u'JSON: {0}'.format(response.json()))
+                return response.json()
+            # no exceptions here, POSTing to Actions may not return data
+        except:
+            raise
+        finally:
+            if response:
+                response.close()
+                self.log.info(u'Closed POST response for {0}'.format(url))
 
     def execute_patch(self, url, data):
-        headers = {
-            'Content-Type': 'application/json',
-        }
-        headers.update(self.base_headers)
+        try:
+            response = None
+            headers = {
+                'Content-Type': 'application/json',
+            }
+            headers.update(self.base_headers)
 
-        data = json.dumps(data)
+            data = json.dumps(data)
 
-        self.log.info(u'PATCH {0}'.format(url))
-        self.log.info(u'Payload: {0}'.format(data))
+            self.log.info(u'PATCH {0}'.format(url))
+            self.log.info(u'Payload: {0}'.format(data))
 
-        response = self._do_patch(url, data=data, headers=headers)
-        self._handle_odata_error(response)
+            response = self._do_patch(url, data=data, headers=headers)
+            self._handle_odata_error(response)
+            response_ct = response.headers.get('content-type', '')
+            if 'application/json' in response_ct:
+                self.log.debug(u'JSON: {0}'.format(response.json()))
+                return response.json()
+        except:
+            raise
+        finally:
+            if response:
+                response.close()
+                self.log.info(u'Closed PATCH response for {0}'.format(url))
 
     def execute_delete(self, url):
-        headers = {}
-        headers.update(self.base_headers)
+        try:
+            response = None
+            headers = {}
+            headers.update(self.base_headers)
 
-        self.log.info(u'DELETE {0}'.format(url))
+            self.log.info(u'DELETE {0}'.format(url))
 
-        response = self._do_delete(url, headers=headers)
-        self._handle_odata_error(response)
+            response = self._do_delete(url, headers=headers)
+            self._handle_odata_error(response)
+            response_ct = response.headers.get('content-type', '')
+            if 'application/json' in response_ct:
+                self.log.debug(u'JSON: {0}'.format(response.json()))
+        except:
+            raise
+        finally:
+            if response:
+                response.close()
+                self.log.info(u'Closed DELETE response for {0}'.format(url))

odata/context.py

@@ -13,8 +13,8 @@ def __init__(self, session=None, auth=None):
         self.log = logging.getLogger('odata.context')
         self.connection = ODataConnection(session=session, auth=auth)
 
-    def query(self, entitycls):
-        q = Query(entitycls, connection=self.connection)
+    def query(self, entitycls, options=None):
+        q = Query(entitycls, connection=self.connection, options=options)
         return q
 
     def call(self, action_or_function, **parameters):
@@ -44,11 +44,29 @@ def delete(self, entity):
         :type entity: EntityBase
         :raises ODataConnectionError: Delete not allowed or a serverside error. Server returned an HTTP error code
         """
-        self.log.info(u'Deleting entity: {0}'.format(entity))
+        self.log.debug(u'Deleting entity: {0}'.format(entity))
         url = entity.__odata__.instance_url
         self.connection.execute_delete(url)
         entity.__odata__.persisted = False
-        self.log.info(u'Success')
+        entity.__odata__.persisted_id = None
+        self.log.debug(u'Success')
+
+    def get(self, entity):
+        """
+        Creates a GET call to the service, fetching the entity
+
+        :type entity: EntityBase
+        """
+        self.log.debug(u'Fetching entity: {0}'.format(entity))
+        url = entity.__odata__.instance_url
+        data = self.connection.execute_get(url)
+        entity.__odata__.reset()
+        if data is not None:
+            entity.__odata__.update(data)
+            entity.__odata__.persisted = True
+            entity.__odata__.persisted_id = entity.__odata__.id
+        self.log.debug(u'Success')
+        return entity
 
     def save(self, entity, force_refresh=True):
         """
@@ -76,12 +94,16 @@ def _insert_new(self, entity):
 
         :type entity: EntityBase
         """
-        url = entity.__odata_url__()
+
+        if entity.__odata__.odata_scope:
+            url = entity.__odata__.odata_scope
+        else:
+            url = entity.__odata_url__()
         if url is None:
             msg = 'Cannot insert Entity that does not belong to EntitySet: {0}'.format(entity)
             raise ODataError(msg)
 
-        self.log.info(u'Saving new entity')
+        self.log.debug(u'Saving new entity')
 
         es = entity.__odata__
         insert_data = es.data_for_insert()
@@ -92,8 +114,9 @@ def _insert_new(self, entity):
 
         if saved_data is not None:
             es.update(saved_data)
+            es.persisted_id = es.id
 
-        self.log.info(u'Success')
+        self.log.debug(u'Success')
 
     def _update_existing(self, entity, force_refresh=True):
         """
@@ -112,18 +135,18 @@ def _update_existing(self, entity, force_refresh=True):
             self.log.debug(u'Nothing to update: {0}'.format(entity))
             return
 
-        self.log.info(u'Updating existing entity: {0}'.format(entity))
+        self.log.debug(u'Updating existing entity: {0}'.format(entity))
 
         url = es.instance_url
 
         saved_data = self.connection.execute_patch(url, patch_data)
         es.reset()
 
         if saved_data is None and force_refresh:
-            self.log.info(u'Reloading entity from service')
+            self.log.debug(u'Reloading entity from service')
             saved_data = self.connection.execute_get(url)
 
         if saved_data is not None:
             entity.__odata__.update(saved_data)
 
-        self.log.info(u'Success')
+        self.log.debug(u'Success')