added in testing files for tables and started playing around with testing generated code

Author: LibbaLawrence

sdk/storage/azure-storage-tables/azure/__init__.py renamed to sdk/Table/azure/__init__.py

@@ -0,0 +1,41 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+# pylint: disable=unused-argument
+
+from azure.core.exceptions import ResourceExistsError
+
+from ._shared.models import StorageErrorCode
+from ._models import QueueProperties
+
+
+def deserialize_metadata(response, obj, headers):
+    raw_metadata = {k: v for k, v in response.headers.items() if k.startswith("x-ms-meta-")}
+    return {k[10:]: v for k, v in raw_metadata.items()}
+
+
+def deserialize_queue_properties(response, obj, headers):
+    metadata = deserialize_metadata(response, obj, headers)
+    queue_properties = QueueProperties(
+        metadata=metadata,
+        **headers
+    )
+    return queue_properties
+
+
+def deserialize_queue_creation(response, obj, headers):
+    if response.status_code == 204:
+        error_code = StorageErrorCode.queue_already_exists
+        error = ResourceExistsError(
+            message="Queue already exists\nRequestId:{}\nTime:{}\nErrorCode:{}".format(
+                headers['x-ms-request-id'],
+                headers['Date'],
+                error_code
+            ),
+            response=response)
+        error.error_code = error_code
+        error.additional_info = {}
+        raise error
+    return headers

sdk/storage/azure-storage-tables/azure/storage/__init__.py renamed to sdk/Table/azure/storage/__init__.py

@@ -0,0 +1,150 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+# pylint: disable=unused-argument
+
+from base64 import b64encode, b64decode
+
+import sys
+import six
+from azure.core.exceptions import DecodeError
+
+from ._shared.encryption import decrypt_queue_message, encrypt_queue_message
+
+
+class MessageEncodePolicy(object):
+
+    def __init__(self):
+        self.require_encryption = False
+        self.key_encryption_key = None
+        self.resolver = None
+
+    def __call__(self, content):
+        if content:
+            content = self.encode(content)
+            if self.key_encryption_key is not None:
+                content = encrypt_queue_message(content, self.key_encryption_key)
+        return content
+
+    def configure(self, require_encryption, key_encryption_key, resolver):
+        self.require_encryption = require_encryption
+        self.key_encryption_key = key_encryption_key
+        self.resolver = resolver
+        if self.require_encryption and not self.key_encryption_key:
+            raise ValueError("Encryption required but no key was provided.")
+
+    def encode(self, content):
+        raise NotImplementedError("Must be implemented by child class.")
+
+
+class MessageDecodePolicy(object):
+
+    def __init__(self):
+        self.require_encryption = False
+        self.key_encryption_key = None
+        self.resolver = None
+
+    def __call__(self, response, obj, headers):
+        for message in obj:
+            if message.message_text in [None, "", b""]:
+                continue
+            content = message.message_text
+            if (self.key_encryption_key is not None) or (self.resolver is not None):
+                content = decrypt_queue_message(
+                    content, response,
+                    self.require_encryption,
+                    self.key_encryption_key,
+                    self.resolver)
+            message.message_text = self.decode(content, response)
+        return obj
+
+    def configure(self, require_encryption, key_encryption_key, resolver):
+        self.require_encryption = require_encryption
+        self.key_encryption_key = key_encryption_key
+        self.resolver = resolver
+
+    def decode(self, content, response):
+        raise NotImplementedError("Must be implemented by child class.")
+
+
+class TextBase64EncodePolicy(MessageEncodePolicy):
+    """Base 64 message encoding policy for text messages.
+
+    Encodes text (unicode) messages to base 64. If the input content
+    is not text, a TypeError will be raised. Input text must support UTF-8.
+    """
+
+    def encode(self, content):
+        if not isinstance(content, six.text_type):
+            raise TypeError("Message content must be text for base 64 encoding.")
+        return b64encode(content.encode('utf-8')).decode('utf-8')
+
+
+class TextBase64DecodePolicy(MessageDecodePolicy):
+    """Message decoding policy for base 64-encoded messages into text.
+
+    Decodes base64-encoded messages to text (unicode). If the input content
+    is not valid base 64, a DecodeError will be raised. Message data must
+    support UTF-8.
+    """
+
+    def decode(self, content, response):
+        try:
+            return b64decode(content.encode('utf-8')).decode('utf-8')
+        except (ValueError, TypeError) as error:
+            # ValueError for Python 3, TypeError for Python 2
+            raise DecodeError(
+                message="Message content is not valid base 64.",
+                response=response,
+                error=error)
+
+
+class BinaryBase64EncodePolicy(MessageEncodePolicy):
+    """Base 64 message encoding policy for binary messages.
+
+    Encodes binary messages to base 64. If the input content
+    is not bytes, a TypeError will be raised.
+    """
+
+    def encode(self, content):
+        if not isinstance(content, six.binary_type):
+            raise TypeError("Message content must be bytes for base 64 encoding.")
+        return b64encode(content).decode('utf-8')
+
+
+class BinaryBase64DecodePolicy(MessageDecodePolicy):
+    """Message decoding policy for base 64-encoded messages into bytes.
+
+    Decodes base64-encoded messages to bytes. If the input content
+    is not valid base 64, a DecodeError will be raised.
+    """
+
+    def decode(self, content, response):
+        try:
+            return b64decode(content.encode('utf-8'))
+        except (ValueError, TypeError) as error:
+            # ValueError for Python 3, TypeError for Python 2
+            raise DecodeError(
+                message="Message content is not valid base 64.",
+                response=response,
+                error=error)
+
+
+class NoEncodePolicy(MessageEncodePolicy):
+    """Bypass any message content encoding."""
+
+    def encode(self, content):
+        if isinstance(content, six.binary_type) and sys.version_info > (3,):
+            raise TypeError(
+                "Message content must not be bytes. Use the BinaryBase64EncodePolicy to send bytes."
+            )
+        return content
+
+
+class NoDecodePolicy(MessageDecodePolicy):
+    """Bypass any message content decoding."""
+
+    def decode(self, content, response):
+        return content

sdk/storage/azure-storage-tables/azure/storage/tables/__init__.py renamed to sdk/Table/azure/storage/tables/__init__.py

@@ -0,0 +1,56 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+import base64
+import hashlib
+import hmac
+
+try:
+    from urllib.parse import quote, unquote
+except ImportError:
+    from urllib2 import quote, unquote # type: ignore
+
+import six
+
+
+def url_quote(url):
+    return quote(url)
+
+
+def url_unquote(url):
+    return unquote(url)
+
+
+def encode_base64(data):
+    if isinstance(data, six.text_type):
+        data = data.encode('utf-8')
+    encoded = base64.b64encode(data)
+    return encoded.decode('utf-8')
+
+
+def decode_base64_to_bytes(data):
+    if isinstance(data, six.text_type):
+        data = data.encode('utf-8')
+    return base64.b64decode(data)
+
+
+def decode_base64_to_text(data):
+    decoded_bytes = decode_base64_to_bytes(data)
+    return decoded_bytes.decode('utf-8')
+
+
+def sign_string(key, string_to_sign, key_is_base64=True):
+    if key_is_base64:
+        key = decode_base64_to_bytes(key)
+    else:
+        if isinstance(key, six.text_type):
+            key = key.encode('utf-8')
+    if isinstance(string_to_sign, six.text_type):
+        string_to_sign = string_to_sign.encode('utf-8')
+    signed_hmac_sha256 = hmac.HMAC(key, string_to_sign, hashlib.sha256)
+    digest = signed_hmac_sha256.digest()
+    encoded_digest = encode_base64(digest)
+    return encoded_digest

sdk/Table/azure/storage/tables/_deserialize.py

@@ -0,0 +1,126 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+import base64
+import hashlib
+import hmac
+import sys
+from io import (SEEK_SET)
+
+from dateutil.tz import tzutc
+
+from ._error import (
+    _ERROR_VALUE_SHOULD_BE_BYTES_OR_STREAM,
+    _ERROR_VALUE_SHOULD_BE_SEEKABLE_STREAM,
+)
+from .models import (
+    _unicode_type,
+)
+
+if sys.version_info < (3,):
+    def _str(value):
+        if isinstance(value, unicode):
+            return value.encode('utf-8')
+
+        return str(value)
+else:
+    _str = str
+
+
+def _to_str(value):
+    return _str(value) if value is not None else None
+
+
+def _int_to_str(value):
+    return str(int(value)) if value is not None else None
+
+
+def _bool_to_str(value):
+    if value is None:
+        return None
+
+    if isinstance(value, bool):
+        if value:
+            return 'true'
+        else:
+            return 'false'
+
+    return str(value)
+
+
+def _to_utc_datetime(value):
+    return value.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+
+def _datetime_to_utc_string(value):
+    # Azure expects the date value passed in to be UTC.
+    # Azure will always return values as UTC.
+    # If a date is passed in without timezone info, it is assumed to be UTC.
+    if value is None:
+        return None
+
+    if value.tzinfo:
+        value = value.astimezone(tzutc())
+
+    return value.strftime('%a, %d %b %Y %H:%M:%S GMT')
+
+
+def _encode_base64(data):
+    if isinstance(data, _unicode_type):
+        data = data.encode('utf-8')
+    encoded = base64.b64encode(data)
+    return encoded.decode('utf-8')
+
+
+def _decode_base64_to_bytes(data):
+    if isinstance(data, _unicode_type):
+        data = data.encode('utf-8')
+    return base64.b64decode(data)
+
+
+def _decode_base64_to_text(data):
+    decoded_bytes = _decode_base64_to_bytes(data)
+    return decoded_bytes.decode('utf-8')
+
+
+def _sign_string(key, string_to_sign, key_is_base64=True):
+    if key_is_base64:
+        key = _decode_base64_to_bytes(key)
+    else:
+        if isinstance(key, _unicode_type):
+            key = key.encode('utf-8')
+    if isinstance(string_to_sign, _unicode_type):
+        string_to_sign = string_to_sign.encode('utf-8')
+    signed_hmac_sha256 = hmac.HMAC(key, string_to_sign, hashlib.sha256)
+    digest = signed_hmac_sha256.digest()
+    encoded_digest = _encode_base64(digest)
+    return encoded_digest
+
+
+def _get_content_md5(data):
+    md5 = hashlib.md5()
+    if isinstance(data, bytes):
+        md5.update(data)
+    elif hasattr(data, 'read'):
+        pos = 0
+        try:
+            pos = data.tell()
+        except:
+            pass
+        for chunk in iter(lambda: data.read(4096), b""):
+            md5.update(chunk)
+        try:
+            data.seek(pos, SEEK_SET)
+        except (AttributeError, IOError):
+            raise ValueError(_ERROR_VALUE_SHOULD_BE_SEEKABLE_STREAM.format('data'))
+    else:
+        raise ValueError(_ERROR_VALUE_SHOULD_BE_BYTES_OR_STREAM.format('data'))
+
+    return base64.b64encode(md5.digest()).decode('utf-8')
+
+
+def _lower(text):
+    return text.lower()