[Csl-878] quizzes library support python (#33)

stanlp1 · esezen · web-flow · commit 5813ee6561e6 · 2022-10-12T20:39:39.000+03:00
* Add quizzes

* lint changes

* Fix exceptions

* Fix catalog test exception method

* Add version_id param

* Tests pass

* Update finalize function name

* Update test names

* Organize get_quiz_results tests

* Add get_quiz_results tests

* Remove todo

Co-authored-by: Enes Kutay SEZEN &lt;eneskutaysezen@gmail.com&gt;
diff --git a/constructor_io/constructor_io.py b/constructor_io/constructor_io.py
@@ -5,13 +5,15 @@
 from constructor_io.modules.autocomplete import Autocomplete
 from constructor_io.modules.browse import Browse
 from constructor_io.modules.catalog import Catalog
+from constructor_io.modules.quizzes import Quizzes
 from constructor_io.modules.recommendations import Recommendations
 from constructor_io.modules.search import Search
 from constructor_io.modules.tasks import Tasks
 
 
 class ConstructorIO:
     # pylint: disable=too-few-public-methods
+    # pylint: disable=too-many-instance-attributes
     '''
         ConstructorIO Python Client
 
@@ -49,6 +51,7 @@ def __init__(self, options) -> None:
         self.recommendations = Recommendations(self.__options)
         self.catalog = Catalog(self.__options)
         self.tasks = Tasks(self.__options)
+        self.quizzes = Quizzes(self.__options)
 
     def get_options(self):
         '''Get client options'''
diff --git a/constructor_io/modules/quizzes.py b/constructor_io/modules/quizzes.py
@@ -0,0 +1,139 @@
+'''Quizzes Module'''
+
+from time import time
+from urllib.parse import quote, urlencode
+
+import requests as r
+
+from constructor_io.helpers.exception import ConstructorException
+from constructor_io.helpers.utils import (clean_params, create_auth_header,
+                                          create_request_headers,
+                                          create_shared_query_params,
+                                          throw_http_exception_from_response)
+
+
+def _create_quizzes_url(quiz_id, parameters, user_parameters, options, path):
+    # pylint: disable=too-many-branches
+    '''Create URL from supplied quiz_id and parameters'''
+    quiz_service_url = 'https://quizzes.cnstrc.com'
+    query_params = create_shared_query_params(options, {}, user_parameters)
+    ans_query_string = ''
+
+    if not quiz_id or not isinstance(quiz_id, str):
+        raise ConstructorException('quiz_id is a required parameter of type str')
+
+    if path == 'finalize' and (not isinstance(parameters.get('a'), list) or len(parameters.get('a')) == 0): # pylint: disable=line-too-long
+        raise ConstructorException('a is a required parameter of type list')
+
+    if parameters:
+        if parameters.get('section'):
+            query_params['section'] = parameters.get('section')
+
+        if parameters.get('version_id'):
+            query_params['version_id'] = parameters.get('version_id')
+
+        if parameters.get('a'):
+            answers_param = []
+            answers = parameters.get('a')
+
+            for question_answer in answers:
+                answers_param.append(','.join(map(str, question_answer)))
+
+            ans_query_string = urlencode({'a': answers_param}, doseq=True)
+
+    query_params['_dt'] = int(time()*1000.0)
+    query_params = clean_params(query_params)
+    query_string = urlencode(query_params, doseq=True)
+
+    return f'{quiz_service_url}/v1/quizzes/{quote(quiz_id)}/{quote(path)}?{query_string}&{ans_query_string}'
+
+class Quizzes:
+    # pylint: disable=too-few-public-methods
+    '''Quizzes Class'''
+
+    def __init__(self, options):
+        self.__options = options or {}
+
+    def get_next_question(self, quiz_id, parameters=None, user_parameters=None):
+        '''
+        Retrieve next question from API
+
+        :param str quiz_id: Quiz Id
+        :param dict parameters: Additional parameters to determine next quiz
+        :param list parameters.a: 2d Array of quiz answers in the format [[1],[1,2]]
+        :param str parameters.section: Section for customer's product catalog
+        :param str parameters.version_id: Specific version_id for the quiz
+        :param dict user_parameters: Parameters relevant to the user request
+        :param int user_parameters.session_id: Session ID, utilized to personalize results
+        :param str user_parameters.client_id: Client ID, utilized to personalize results
+        :param str user_parameters.user_ip: Origin user IP, from client
+        :param str user_parameters.user_agent: Origin user agent, from client
+        :return: dict
+        '''
+
+        if not parameters:
+            parameters = {}
+        if not user_parameters:
+            user_parameters = {}
+
+        request_url = _create_quizzes_url(quiz_id, parameters, user_parameters, self.__options, 'next') # pylint: disable=line-too-long
+        requests = self.__options.get('requests') or r
+
+        response = requests.get(
+            request_url,
+            auth=create_auth_header(self.__options),
+            headers=create_request_headers(self.__options, user_parameters)
+        )
+
+        if not response.ok:
+            throw_http_exception_from_response(response)
+
+        json = response.json()
+
+        if json:
+            if json.get('version_id'):
+                return json
+
+        raise ConstructorException('get_next_question response data is malformed')
+
+    def get_quiz_results(self, quiz_id, parameters=None, user_parameters=None):
+        '''
+        Retrieve quiz results from API
+
+        :param str quiz_id: Quiz Id
+        :param dict parameters: Additional parameters to determine next quiz
+        :param list parameters.a: 2d Array of quiz answers in the format [[1],[1,2]]
+        :param str parameters.section: Section for customer's product catalog
+        :param str parameters.version_id: Specific version_id for the quiz
+        :param dict user_parameters: Parameters relevant to the user request
+        :param int user_parameters.session_id: Session ID, utilized to personalize results
+        :param str user_parameters.client_id: Client ID, utilized to personalize results
+        :param str user_parameters.user_ip: Origin user IP, from client
+        :param str user_parameters.user_agent: Origin user agent, from client
+        :return: dict
+        '''
+
+        if not parameters:
+            parameters = {}
+        if not user_parameters:
+            user_parameters = {}
+
+        request_url = _create_quizzes_url(quiz_id, parameters, user_parameters, self.__options, 'finalize') #pylint: disable=line-too-long
+        requests = self.__options.get('requests') or r
+
+        response = requests.get(
+            request_url,
+            auth=create_auth_header(self.__options),
+            headers=create_request_headers(self.__options, user_parameters)
+        )
+
+        if not response.ok:
+            throw_http_exception_from_response(response)
+
+        json = response.json()
+
+        if json:
+            if json.get('version_id'):
+                return json
+
+        raise ConstructorException('get_quiz_results response data is malformed')
diff --git a/tests/modules/test_quizzes.py b/tests/modules/test_quizzes.py
@@ -0,0 +1,124 @@
+'''ConstructorIO Python Client - Quizzes Tests'''
+
+from os import environ
+
+from pytest import raises
+
+from constructor_io.constructor_io import ConstructorIO
+from constructor_io.helpers.exception import (ConstructorException,
+                                              HttpException)
+
+TEST_API_KEY = environ['TEST_API_KEY']
+TEST_API_TOKEN = environ['TEST_API_TOKEN']
+QUIZ_ID = 'test-quiz'
+VALID_QUIZ_ANS = [[1], [1, 2], ['seen']]
+VALID_OPTIONS = { 'api_key': TEST_API_KEY, 'api_token': TEST_API_TOKEN}
+
+def test_get_next_question_with_valid_parameters():
+    '''Should return a response with a valid quiz_id'''
+
+    quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+    response = quizzes.get_next_question('test-quiz')
+
+    assert isinstance(response.get('version_id'), str)
+    assert isinstance(response.get('next_question'), dict)
+
+def test_get_next_question_with_answer_parameter():
+    '''Should return a response with a valid quiz_id and answer parameter'''
+
+    quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+    response = quizzes.get_next_question('test-quiz', { 'a': VALID_QUIZ_ANS })
+
+    assert isinstance(response.get('version_id'), str)
+    assert isinstance(response.get('next_question'), dict)
+    assert response.get('next_question').get('id') == 4
+
+def test_get_next_question_with_no_quiz_id():
+    '''Should raise an exception with no quiz_id'''
+
+    with raises(
+        ConstructorException,
+        match=r'quiz_id is a required parameter of type str'
+    ):
+        quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+        quizzes.get_next_question(None)
+
+def test_get_next_question_with_invalid_quiz_id():
+    '''Should raise an exception with invalid quiz_id'''
+
+    with raises(
+        ConstructorException,
+        match=r'The quiz you requested, "abcd" was not found, please specify a valid quiz id before trying again.' # pylint: disable=line-too-long
+    ):
+        quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+        quizzes.get_next_question('abcd')
+
+def test_get_next_question_with_invalid_key():
+    '''Should raise an exception given invalid index_key/api_key'''
+
+    with raises(
+        ConstructorException,
+        match=r'The quiz you requested, "test-quiz" was not found, please specify a valid quiz id before trying again.' # pylint: disable=line-too-long
+    ):
+        quizzes = ConstructorIO({'api_key': 'notavalidkey', 'api_token': TEST_API_TOKEN}).quizzes
+        quizzes.get_next_question(QUIZ_ID, {'a': VALID_QUIZ_ANS})
+
+def test_get_quiz_results_with_valid_parameters():
+    '''Should return a response with a valid quiz_id, a(answers)'''
+
+    quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+    response = quizzes.get_quiz_results(QUIZ_ID, {'a': VALID_QUIZ_ANS})
+
+    assert isinstance(response.get('version_id'), str)
+    assert isinstance(response.get('result'), dict)
+    assert isinstance(response.get('result').get('results_url'), str)
+
+def test_get_quiz_results_with_no_quiz_id():
+    '''Should raise an exception with no quiz_id'''
+
+    with raises(
+        ConstructorException,
+        match=r'quiz_id is a required parameter of type str'
+    ):
+        quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+        quizzes.get_quiz_results(None)
+
+def test_get_quiz_results_with_invalid_quiz_id():
+    '''Should raise an exception given invalid quiz_id'''
+
+    with raises(
+        HttpException,
+        match=r'The quiz you requested, "abcd" was not found, please specify a valid quiz id before trying again.' # pylint: disable=line-too-long
+    ):
+        quizzes = ConstructorIO({'api_key': 'notavalidkey', 'api_token': TEST_API_TOKEN}).quizzes
+        quizzes.get_quiz_results('abcd', {'a': VALID_QUIZ_ANS})
+
+def test_get_quiz_results_with_invalid_key():
+    '''Should raise an exception given invalid index_key/api_key'''
+
+    with raises(
+        HttpException,
+        match=r'The quiz you requested, "test-quiz" was not found, please specify a valid quiz id before trying again.' # pylint: disable=line-too-long
+    ):
+        quizzes = ConstructorIO({'api_key': 'notavalidkey', 'api_token': TEST_API_TOKEN}).quizzes
+        quizzes.get_quiz_results(QUIZ_ID, {'a': VALID_QUIZ_ANS})
+
+def test_get_quiz_results_with_empty_answers():
+    '''Should raise an exception given an empty answers parameter'''
+
+    with raises(
+        ConstructorException,
+        match=r'a is a required parameter of type list'
+    ):
+        quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+        quizzes.get_quiz_results(QUIZ_ID, {'a': []})
+
+def test_get_quiz_results_with_no_answers():
+    '''Should raise an exception given an nonexistent answers parameter'''
+
+    with raises(
+        ConstructorException,
+        match=r'a is a required parameter of type list'
+    ):
+        quizzes = ConstructorIO(VALID_OPTIONS).quizzes
+        quizzes.get_quiz_results(QUIZ_ID, { })
