It's working

Author: fatimarahman

.gitignore

@@ -5,3 +5,4 @@ __pycache__/
 *env/
 *.py[cod]
 *$py.class
+*.pytest_cache

pyproject.toml

@@ -75,3 +75,11 @@ development = [
     "pytest-mock>=3.10.0",
     "requests-mock>=1.10.0"
 ]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+addopts = "-ra -q"
+pythonpath = "src"
+testpaths = [
+    "tests"
+]

src/nypl_py_utils/classes/avro_client.py

@@ -1,5 +1,6 @@
 import avro.schema
 import base64
+import json
 import requests
 
 from avro.schema import AvroException
@@ -114,8 +115,8 @@ def decode_record(self, record, encoding="binary"):
 
         Returns a dictionary where each key is a field in the schema.
         """
-        self.logger.debug('Decoding {rec} using {schema} schema'.format(
-            rec=record, schema=self.schema.name))
+        self.logger.info('Decoding {rec} of type {type} using {schema} schema'.format(
+            rec=record, type=encoding, schema=self.schema.name))
 
         if encoding == "base64":
             return self._decode_base64(record)
@@ -125,9 +126,18 @@ def decode_record(self, record, encoding="binary"):
             self.logger.error('Failed to decode record due to encoding type: {}'.format(encoding))
             raise AvroClientError(
                 'Invalid encoding type: {}'.format(encoding))
-
+        
     def _decode_base64(self, record):
-        return base64.b64decode(record).decode('utf-8')
+        decoded_data = base64.b64decode(record).decode("utf-8")
+        try:
+            return json.loads(decoded_data)
+        except Exception as e:
+            if isinstance(decoded_data, bytes):
+                self._decode_binary(decoded_data) 
+            else:
+                self.logger.error('Failed to decode record: {}'.format(e))
+                raise AvroClientError(
+                    'Failed to decode record: {}'.format(e)) from None
 
     def _decode_binary(self, record):
         datum_reader = DatumReader(self.schema)

tests/test_avro_client.py

@@ -0,0 +1,102 @@
+import json
+import pytest
+
+from nypl_py_utils.classes.avro_client import AvroDecoder, AvroEncoder, AvroClientError
+from requests.exceptions import ConnectTimeout
+
+_TEST_SCHEMA = {'data': {'schema': json.dumps({
+    'name': 'TestSchema',
+    'type': 'record',
+    'fields': [
+        {
+            'name': 'patron_id',
+            'type': 'int'
+        },
+        {
+            'name': 'library_branch',
+            'type': ['null', 'string']
+        }
+    ]
+})}}
+
+class TestAvroClient:
+
+    @pytest.fixture
+    def test_avro_encoder_instance(self, requests_mock):
+        requests_mock.get(
+            'https://test_schema_url', text=json.dumps(_TEST_SCHEMA))
+        return AvroEncoder('https://test_schema_url')
+
+    @pytest.fixture
+    def test_avro_decoder_instance(self, requests_mock):
+        requests_mock.get(
+            'https://test_schema_url', text=json.dumps(_TEST_SCHEMA))
+        return AvroDecoder('https://test_schema_url')
+
+    def test_get_json_schema(self, test_avro_encoder_instance, test_avro_decoder_instance):
+        assert test_avro_encoder_instance.schema == _TEST_SCHEMA['data']['schema']
+        assert test_avro_decoder_instance.schema == _TEST_SCHEMA['data']['schema']
+
+    def test_request_error(self, requests_mock):
+        requests_mock.get('https://test_schema_url', exc=ConnectTimeout)
+        with pytest.raises(AvroClientError):
+            AvroEncoder('https://test_schema_url')
+
+    def test_bad_json_error(self, requests_mock):
+        requests_mock.get(
+            'https://test_schema_url', text='bad json')
+        with pytest.raises(AvroClientError):
+            AvroEncoder('https://test_schema_url')
+
+    def test_missing_key_error(self, requests_mock):
+        requests_mock.get(
+            'https://test_schema_url', text=json.dumps({'field': 'value'}))
+        with pytest.raises(AvroClientError):
+            AvroEncoder('https://test_schema_url')
+
+    def test_encode_record(self, test_avro_encoder_instance, test_avro_decoder_instance):
+        TEST_RECORD = {'patron_id': 123, 'library_branch': 'aa'}
+        encoded_record = test_avro_encoder_instance.encode_record(TEST_RECORD)
+        assert type(encoded_record) is bytes
+        assert test_avro_decoder_instance.decode_record(encoded_record) == TEST_RECORD
+
+    def test_encode_record_error(self, test_avro_encoder_instance):
+        TEST_RECORD = {'patron_id': 123, 'bad_field': 'bad'}
+        with pytest.raises(AvroClientError):
+            test_avro_encoder_instance.encode_record(TEST_RECORD)
+
+    def test_encode_batch(self, test_avro_encoder_instance, test_avro_decoder_instance):
+        TEST_BATCH = [
+            {'patron_id': 123, 'library_branch': 'aa'},
+            {'patron_id': 456, 'library_branch': None},
+            {'patron_id': 789, 'library_branch': 'bb'}]
+        encoded_records = test_avro_encoder_instance.encode_batch(TEST_BATCH)
+        assert len(encoded_records) == len(TEST_BATCH)
+        for i in range(3):
+            assert type(encoded_records[i]) is bytes
+            assert test_avro_decoder_instance.decode_record(
+                encoded_records[i]) == TEST_BATCH[i]
+
+    def test_encode_batch_error(self, test_avro_encoder_instance):
+        BAD_BATCH = [
+            {'patron_id': 123, 'library_branch': 'aa'},
+            {'patron_id': 456, 'bad_field': 'bad'}]
+        with pytest.raises(AvroClientError):
+            test_avro_encoder_instance.encode_batch(BAD_BATCH)
+
+    def test_decode_record_binary(self, test_avro_decoder_instance):
+        TEST_DECODED_RECORD = {"patron_id": 123, "library_branch": "aa"}
+        TEST_ENCODED_RECORD = b'\xf6\x01\x02\x04aa'
+        assert test_avro_decoder_instance.decode_record(
+            TEST_ENCODED_RECORD) == TEST_DECODED_RECORD
+    
+    def test_decode_record_b64(self, test_avro_decoder_instance):
+        TEST_DECODED_RECORD = {"patron_id'": 123, "library_branch": "aa"}
+        TEST_ENCODED_RECORD = "eyJwYXRyb25faWQnIjogMTIzLCAibGlicmFyeV9icmFuY2giOiAiYWEifQ=="
+        assert test_avro_decoder_instance.decode_record(
+            TEST_ENCODED_RECORD, "base64") == TEST_DECODED_RECORD
+
+    def test_decode_record_error(self, test_avro_decoder_instance):
+        TEST_ENCODED_RECORD = b'bad-encoding'
+        with pytest.raises(AvroClientError):
+            test_avro_decoder_instance.decode_record(TEST_ENCODED_RECORD)