adding api key parser

Author: david-schrenker

socketlabs/injectionapi/core/apikeyparser.py

@@ -0,0 +1,42 @@
+from .stringextension import StringExtension
+from .apikeyparseresult import ApiKeyParseResult
+
+class ApiKeyParser(object):
+    """
+    Wrapper of the Http Client to handle threading for async
+    """
+
+    def parse(self, whole_api_key: str):
+        """
+        Parse the API key to determine what kind of key was provided.
+        :param whole_api_key: A ApiKeyParseResult with the parsing results
+        :type whole_api_key: string
+        :return the ApiKeyParseResult from the request
+        :rtype ApiKeyParseResult
+        """
+
+        if StringExtension.is_none_or_white_space(whole_api_key):
+            return ApiKeyParseResult.InvalidEmptyOrWhitespace
+
+        if len(whole_api_key) != 61:
+            return ApiKeyParseResult.InvalidKeyLength
+
+        if whole_api_key.index('.') == -1:
+            return ApiKeyParseResult.InvalidKeyFormat
+
+        public_part_end = whole_api_key[0:50].index('.')
+        if public_part_end == -1:
+            return ApiKeyParseResult.InvalidUnableToExtractPublicPart
+
+        public_part = whole_api_key[0:public_part_end]
+        if len(public_part) != 20:
+            return ApiKeyParseResult.InvalidPublicPartLength
+
+        if len(whole_api_key) <= public_part_end + 1:
+            return ApiKeyParseResult.InvalidUnableToExtractSecretPart
+
+        private_part = whole_api_key[public_part_end + 1:len(whole_api_key)]
+        if len(private_part) != 40:
+            return ApiKeyParseResult.InvalidSecretPartLength
+
+        return ApiKeyParseResult.Success

socketlabs/injectionapi/core/apikeyparseresult.py

@@ -0,0 +1,45 @@
+from enum import Enum
+
+
+class ApiKeyParseResult(Enum):
+    """
+    Enumerated result of parsing the API Key
+    """
+
+    """ No result could be produced. """
+    NoneSet = 0
+
+    """ The key was found to be blank or invalid. """
+    InvalidEmptyOrWhitespace = 1
+
+    """ The public portion of the key was unable to be parsed. """
+    InvalidUnableToExtractPublicPart = 2
+
+    """ The secret portion of the key was unable to be parsed. """
+    InvalidUnableToExtractSecretPart = 3
+
+    """ Key was successfully parsed. """
+    Success = 4
+
+    def __str__(self):
+        """
+        String representation of the SendResult Enum
+        :return the string
+        :rtype str
+        """
+        switcher = {
+            0: "No result could be produced.",
+            1: "The key was found to be blank or invalid.",
+            2: "The public portion of the key was unable to be parsed.",
+            3: "The secret portion of the key was unable to be parsed.",
+            4: "Key was successfully parsed.",
+        }
+        return switcher.get(self.value, "An error has occurred that was unforeseen")
+
+    def describe(self):
+        """
+        string output of the
+        :return the string
+        :rtype str
+        """
+        return self.name, self.value, self.__str__

socketlabs/injectionapi/socketlabsclient.py

@@ -13,6 +13,8 @@
 from .message.bulkmessage import BulkMessage
 from .proxy import Proxy
 from .sendresult import SendResult
+from .core.apikeyparser import ApiKeyParser
+from .core.apikeyparseresult import ApiKeyParseResult
 
 
 class SocketLabsClient(object):
@@ -81,13 +83,15 @@ def number_of_retries(self):
     def number_of_retries(self, retries: int):
         self._number_of_retries = retries
 
-    def __build_http_request(self):
+    def __build_http_request(self, authentication: str):
         """
         Build the HttpRequest. Will add the proxy, if set
+        :param authentication: the API key to include as a bearer token
+        :type authentication: object
         :return the HttpRequest object to use for the request
         :rtype HttpRequest
         """
-        req = HttpRequest(HttpRequest.HttpRequestMethod.POST, self.__endpoint, self.request_timeout)
+        req = HttpRequest(HttpRequest.HttpRequestMethod.POST, self.__endpoint, self.request_timeout, authentication)
         if self._http_proxy is not None:
             req.proxy = self._http_proxy
         return req
@@ -119,10 +123,19 @@ def __send_basic_message(self, message: BasicMessage):
         if not resp.result == SendResult.Success:
             return resp
 
+        api_key_parser = ApiKeyParser()
+        parse_result = api_key_parser.parse(self._api_key)
+
         req_factory = InjectionRequestFactory(self._server_id, self._api_key)
+        http_request = self.__build_http_request("")
+
+        if parse_result == ApiKeyParseResult.Success:
+            req_factory = InjectionRequestFactory(self._server_id, "")
+            http_request = self.__build_http_request(self._api_key)
+
         body = req_factory.generate_request(message)
 
-        retry_handler = RetryHandler(self.__build_http_request(), RetrySettings(self.number_of_retries))
+        retry_handler = RetryHandler(http_request, RetrySettings(self.number_of_retries))
         response = retry_handler.send(body)
 
         data = response.read().decode("utf-8")
@@ -143,10 +156,19 @@ def __send_bulk_message(self, message: BulkMessage):
         if not resp.result == SendResult.Success:
             return resp
 
+        api_key_parser = ApiKeyParser()
+        parse_result = api_key_parser.parse(self._api_key)
+
         req_factory = InjectionRequestFactory(self._server_id, self._api_key)
+        http_request = self.__build_http_request("")
+
+        if parse_result == ApiKeyParseResult.Success:
+            req_factory = InjectionRequestFactory(self._server_id, "")
+            http_request = self.__build_http_request(self._api_key)
+
         body = req_factory.generate_request(message)
 
-        retry_handler = RetryHandler(self.__build_http_request(), RetrySettings(self.number_of_retries))
+        retry_handler = RetryHandler(http_request, RetrySettings(self.number_of_retries))
         response = retry_handler.send(body)
 
         data = response.read().decode("utf-8")