This contains all the bug fixes after first official publish and also added some tests.

Author: weidong huang

README.md

@@ -45,20 +45,21 @@ the local Storage Emulator (with the exception of Service Bus features).
 # Usage
 ## Table Storage
 
-To ensure a table exists, call **create_table**:
+To ensure a table exists, call **create\_table**:
 
 ```Python
 from azure.storage import TableService
 ts = TableService(account_name, account_key)
-table = ts.create_table('tasktable')
+ts.create_table('tasktable')
 ```
 
-A new entity can be added by calling **insert_entity**:
+A new entity can be added by calling **insert\_entity**:
 
 ```Python
+from datetime import datetime
 ts = TableService(account_name, account_key)
-table = ts.create_table('tasktable')
-table.insert_entity(
+ts.create_table('tasktable')
+ts.insert_entity(
      'tasktable',
      {
         'PartitionKey' : 'tasksSeattle',
@@ -69,7 +70,7 @@ table.insert_entity(
 )
 ```
 
-The method **get_entity** can then be used to fetch the entity that was just inserted:
+The method **get\_entity** can then be used to fetch the entity that was just inserted:
 
 ```Python
 ts = TableService(account_name, account_key)
@@ -78,27 +79,25 @@ entity = ts.get_entity('tasktable', 'tasksSeattle', '1')
 
 ## Blob Storage
 
-The **create_container** method can be used to create a 
+The **create\_container** method can be used to create a 
 container in which to store a blob:
 
 ```Python
 from azure.storage import BlobService
-blob_service = BlobService()
-container = blob_service.create_container('taskcontainer')
+blob_service = BlobService(account_name, account_key)
+blob_service.create_container('taskcontainer')
 ```
 
-To upload a file (assuming it is called task1-upload.txt, it contains the exact text "hello world" (no quotation marks), and it is placed in the same folder as the script below), the method **put_blob** can be used:
+To upload a file (assuming it is called task1-upload.txt, it contains the exact text "hello world" (no quotation marks), and it is placed in the same folder as the script below), the method **put\_blob** can be used:
 
 ```Python
 from azure.storage import BlobService
 blob_service = BlobService(account_name, account_key)
-blob_service.put_blob('taskcontainer', 'task1', 
-blobService = azure.createBlobService()
-blobService.put_blob('taskcontainer', 'task1', file('task1-upload.txt').read())
+blob_service.put_blob('taskcontainer', 'task1', file('task1-upload.txt').read(), 'BlockBlob')
 
 ```
 
-To download the blob and write it to the file system, the **get_blob** method can be used:
+To download the blob and write it to the file system, the **get\_blob** method can be used:
 
 ```Python
 from azure.storage import BlobService
@@ -108,85 +107,89 @@ blob = blob_service.get_blob('taskcontainer', 'task1')
 
 ## Storage Queues
 
-The **create_queue** method can be used to ensure a queue exists:
+The **create\_queue** method can be used to ensure a queue exists:
 
 ```Python
 from azure.storage import QueueService
 queue_service = QueueService(account_name, account_key)
-queue = queue_service.create_queue('taskqueue')
+queue_service.create_queue('taskqueue')
 ```
 
-The **put_message** method can then be called to insert the message into the queue:
+The **put\_message** method can then be called to insert the message into the queue:
 
 ```Python
 from azure.storage import QueueService
 queue_service = QueueService(account_name, account_key)
 queue_service.put_message('taskqueue', 'Hello world!')
 ```
 
-It is then possible to call the **get___messages** method, process the message and then call **delete_message** on the messages ID. This two-step process ensures messages don't get lost when they are removed from the queue.
+It is then possible to call the **get\_messages** method, process the message and then call **delete\_message** with the message id and receipt. This two-step process ensures messages don't get lost when they are removed from the queue.
 
 ```Python
 from azure.storage import QueueService
 queue_service = QueueService(account_name, account_key)
 messages = queue_service.get_messages('taskqueue')
-queue_service.delete_message('taskqueue', messages[0].message_id)
+queue_service.delete_message('taskqueue', messages[0].message_id, messages[0].pop_receipt)
 ```
 
 ## ServiceBus Queues
 
 ServiceBus Queues are an alternative to Storage Queues that might be useful in scenarios where more advanced messaging features are needed (larger message sizes, message ordering, single-operaiton destructive reads, scheduled delivery) using push-style delivery (using long polling).
 
-The **create_queue** method can be used to ensure a queue exists:
+The **create\_queue** method can be used to ensure a queue exists:
 
 ```Python
 from azure.servicebus import ServiceBusService
-sbs = ServiceBusService(service_namespace, account_key)
-queue = sbs.create_queue('taskqueue');
+sbs = ServiceBusService(service_namespace, account_key, 'owner')
+sbs.create_queue('taskqueue')
 ```
 
-The **send__queue__message** method can then be called to insert the message into the queue:
+The **send\_queue\_message** method can then be called to insert the message into the queue:
 
 ```Python
-from azure.servicebus import ServiceBusService
-sbs = ServiceBusService(service_namespace, account_key)
-sbs.send_queue_message('taskqueue', 'Hello World!')
+from azure.servicebus import ServiceBusService, Message
+sbs = ServiceBusService(service_namespace, account_key, 'owner')
+msg = Message('Hello World!')
+sbs.send_queue_message('taskqueue', msg)
 ```
 
-It is then possible to call the **read__delete___queue__message** method to dequeue the message.
+It is then possible to call the **receive\_queue\_message** method to dequeue the message.
 
 ```Python
 from azure.servicebus import ServiceBusService
-sbs = ServiceBusService(service_namespace, account_key)
-msg = sbs.read_delete_queue_message('taskqueue')
+sbs = ServiceBusService(service_namespace, account_key, 'owner')
+msg = sbs.receive_queue_message('taskqueue')
 ```
 
 ## ServiceBus Topics
 
 ServiceBus topics are an abstraction on top of ServiceBus Queues that make pub/sub scenarios easy to implement.
 
-The **create_topic** method can be used to create a server-side topic:
+The **create\_topic** method can be used to create a server-side topic:
 
 ```Python
 from azure.servicebus import ServiceBusService
-sbs = ServiceBusService(service_namespace, account_key)
-topic = sbs.create_topic('taskdiscussion')
+sbs = ServiceBusService(service_namespace, account_key, 'owner')
+sbs.create_topic('taskdiscussion')
 ```
 
-The **send__topic__message** method can be used to send a message to a topic:
+The **send\_topic\_message** method can be used to send a message to a topic:
 
 ```Python
-from azure.servicebus import ServiceBusService
-sbs = ServiceBusService(service_namespace, account_key)
-sbs.send_topic_message('taskdiscussion', 'Hello world!')
+from azure.servicebus import ServiceBusService, Message
+sbs = ServiceBusService(service_namespace, account_key, 'owner')
+msg = Message('Hello World!')
+sbs.send_topic_message('taskdiscussion', msg)
 ```
 
-A client can then create a subscription and start consuming messages by calling the **create__subscription** method followed by the **receive__subscription__message** method. Please note that any messages sent before the subscription is created will not be received.
+A client can then create a subscription and start consuming messages by calling the **create\_subscription** method followed by the **receive\_subscription\_message** method. Please note that any messages sent before the subscription is created will not be received.
 
 ```Python
-from azure.servicebus import ServiceBusService
-sbs = ServiceBusService(service_namespace, account_key)
+from azure.servicebus import ServiceBusService, Message
+sbs = ServiceBusService(service_namespace, account_key, 'owner')
 sbs.create_subscription('taskdiscussion', 'client1')
+msg = Message('Hello World!')
+sbs.send_topic_message('taskdiscussion', msg)
 msg = sbs.receive_subscription_message('taskdiscussion', 'client1')
 ```
 

src/azure/__init__.py

@@ -43,12 +43,12 @@
 _ERROR_CANNOT_FIND_ROW_KEY = 'Cannot find row key in request.'
 _ERROR_INCORRECT_TABLE_IN_BATCH = 'Table should be the same in a batch operations'
 _ERROR_INCORRECT_PARTITION_KEY_IN_BATCH = 'Partition Key should be the same in a batch operations'
-_ERROR_DUPLICATE_ROW_KEY_IN_BATCH = 'Partition Key should be the same in a batch operations'
+_ERROR_DUPLICATE_ROW_KEY_IN_BATCH = 'Row Keys should not be the same in a batch operations'
 _ERROR_BATCH_COMMIT_FAIL = 'Batch Commit Fail'
 _ERROR_MESSAGE_NOT_PEEK_LOCKED_ON_DELETE = 'Message is not peek locked and cannot be deleted.'
 _ERROR_MESSAGE_NOT_PEEK_LOCKED_ON_UNLOCK = 'Message is not peek locked and cannot be unlocked.'
-_ERROR_QUEUE_NOT_FOUND = 'Queue is not Found'
-_ERROR_TOPIC_NOT_FOUND = 'Topic is not Found'
+_ERROR_QUEUE_NOT_FOUND = 'Queue was not found'
+_ERROR_TOPIC_NOT_FOUND = 'Topic was not found'
 _ERROR_CONFLICT = 'Conflict'
 _ERROR_NOT_FOUND = 'Not found'
 _ERROR_UNKNOWN = 'Unknown error (%s)'
@@ -58,6 +58,8 @@
 _ERROR_VALUE_SHOULD_NOT_BE_NULL  = '%s should not be None.'
 _ERROR_CANNOT_SERIALIZE_VALUE_TO_ENTITY = 'Cannot serialize the specified value (%s) to an entity.  Please use an EntityProperty (which can specify custom types), int, str, bool, or datetime'
 
+METADATA_NS = 'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'
+
 class WindowsAzureData(object):
     ''' This is the base of data class.  It is only used to check whether it is instance or not. '''
     pass
@@ -80,8 +82,11 @@ def __init__(self, message):
         self.message = message
 
 class Feed:
-    def __init__(self, type):
-        self.type = type
+    pass
+
+class HeaderDict(dict):
+    def __getitem__(self, index):
+        return super(HeaderDict, self).__getitem__(index.lower())
 
 def _get_readable_id(id_name):
     """simplified an id to be more friendly for us people"""
@@ -97,6 +102,9 @@ def _get_entry_properties(xmlstr, include_id):
     properties = {}
 
     for entry in _get_child_nodes(xmldoc, 'entry'):
+        etag = entry.getAttributeNS(METADATA_NS, 'etag')
+        if etag:
+            properties['etag'] = etag
         for updated in _get_child_nodes(entry, 'updated'):
             properties['updated'] = updated.firstChild.nodeValue
         for name in _get_children_from_path(entry, 'author', 'name'):
@@ -109,6 +117,14 @@ def _get_entry_properties(xmlstr, include_id):
 
     return properties
 
+def _get_first_child_node_value(parent_node, node_name):
+    xml_attrs = _get_child_nodes(parent_node, node_name)
+    if xml_attrs:
+        xml_attr = xml_attrs[0]
+        if xml_attr.firstChild:
+            value = xml_attr.firstChild.nodeValue
+            return value
+
 def _get_child_nodes(node, tagName):
     return [childNode for childNode in node.getElementsByTagName(tagName)
             if childNode.parentNode == node]
@@ -142,7 +158,7 @@ def _create_entry(entry_body):
         updated_str += '+00:00'
 
     entry_start = '''<?xml version="1.0" encoding="utf-8" standalone="yes"?>   
-<entry xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom">
+<entry xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom" >
 <title /><updated>{updated}</updated><author><name /></author><id />
 <content type="application/xml">
     {body}</content></entry>'''
@@ -242,9 +258,23 @@ def _clone_node_with_namespaces(node_to_clone, original_doc):
     return clone
 
 def _convert_response_to_feeds(response, convert_func):
-    feeds = []
+    if response is None:
+        return None
+
+    feeds = _list_of(Feed)
+    
+    x_ms_continuation = HeaderDict()
+    for name, value in response.headers:
+        if 'x-ms-continuation' in name:
+            x_ms_continuation[name[len('x-ms-continuation')+1:]] = value
+    if x_ms_continuation:
+        setattr(feeds, 'x_ms_continuation', x_ms_continuation)
+
     xmldoc = minidom.parseString(response.body)
-    for xml_entry in _get_children_from_path(xmldoc, 'feed', 'entry'):
+    xml_entries = _get_children_from_path(xmldoc, 'feed', 'entry')
+    if not xml_entries:
+        xml_entries = _get_children_from_path(xmldoc, 'entry') #in some cases, response contains only entry but no feed
+    for xml_entry in xml_entries:
         new_node = _clone_node_with_namespaces(xml_entry, xmldoc)
         feeds.append(convert_func(new_node.toxml()))
 
@@ -254,16 +284,19 @@ def _validate_not_none(param_name, param):
     if param is None:
         raise TypeError(_ERROR_VALUE_SHOULD_NOT_BE_NULL % (param_name))
 
-def _html_encode(html):
-    ch_map = (('&', '&amp;'), ('<', '&lt;'), ('>', '&gt;'), ('"', '&quot'), ('\'', '&apos'))
-    for name, value in ch_map:
-        html = html.replace(name, value)
-    return html
-
 def _fill_list_of(xmldoc, element_type):
     xmlelements = _get_child_nodes(xmldoc, element_type.__name__)
     return [_parse_response_body(xmlelement.toxml(), element_type) for xmlelement in xmlelements]
 
+def _fill_dict(xmldoc, element_name):    
+    xmlelements = _get_child_nodes(xmldoc, element_name)
+    if xmlelements:
+        return_obj = {}
+        for child in xmlelements[0].childNodes:
+            if child.firstChild:
+                return_obj[child.nodeName] = child.firstChild.nodeValue
+        return return_obj
+
 def _fill_instance_child(xmldoc, element_name, return_type):
     '''Converts a child of the current dom element to the specified type.  The child name
     '''
@@ -272,7 +305,10 @@ def _fill_instance_child(xmldoc, element_name, return_type):
     if not xmlelements:
         return None
 
-    return _fill_instance_element(xmlelements[0], return_type)
+    return_obj = return_type()
+    _fill_data_to_return_object(xmlelements[0], return_obj)
+
+    return return_obj
 
 def _fill_instance_element(element, return_type):
     """Converts a DOM element into the specified object""" 
@@ -367,22 +403,27 @@ def _parse_response(response, return_type):
     '''
     return _parse_response_body(response.body, return_type)
 
+def _fill_data_to_return_object(node, return_obj):
+    for name, value in vars(return_obj).iteritems():
+        if isinstance(value, _list_of):
+            setattr(return_obj, name, _fill_list_of(node, value.list_type))
+        elif isinstance(value, WindowsAzureData):
+            setattr(return_obj, name, _fill_instance_child(node, name, value.__class__))
+        elif isinstance(value, dict):
+            setattr(return_obj, name, _fill_dict(node, _get_serialization_name(name)))
+        else:
+            value = _fill_data_minidom(node, name, value)
+            if value is not None:
+                setattr(return_obj, name, value)
+
 def _parse_response_body(respbody, return_type):
     '''
     parse the xml and fill all the data into a class of return_type
     '''
     doc = minidom.parseString(respbody)
     return_obj = return_type()
     for node in _get_child_nodes(doc, return_type.__name__):
-        for name, value in vars(return_obj).iteritems():
-            if isinstance(value, _list_of):
-                setattr(return_obj, name, _fill_list_of(node, value.list_type))
-            elif isinstance(value, WindowsAzureData):
-                setattr(return_obj, name, _fill_instance_child(node, name, value.__class__))
-            else:
-                value = _fill_data_minidom(node, name, value)
-                if value is not None:
-                    setattr(return_obj, name, value)
+        _fill_data_to_return_object(node, return_obj)
 
     return return_obj
 
@@ -446,11 +487,12 @@ def _dont_fail_not_exist(error):
 
 def _parse_response_for_dict(response):
     ''' Extracts name-values from response header. Filter out the standard http headers.'''
-
+    
+    if response is None:
+        return None
     http_headers = ['server', 'date', 'location', 'host', 
-                    'via', 'proxy-connection', 'x-ms-version', 'connection',
-                    'content-length']
-    return_dict = {}
+                    'via', 'proxy-connection', 'connection']
+    return_dict = HeaderDict()
     if response.headers:
         for name, value in response.headers:
             if not name.lower() in http_headers:
@@ -461,6 +503,8 @@ def _parse_response_for_dict(response):
 def _parse_response_for_dict_prefix(response, prefix):
     ''' Extracts name-values for names starting with prefix from response header. Filter out the standard http headers.'''
 
+    if response is None:
+        return None
     return_dict = {}    
     orig_dict = _parse_response_for_dict(response)
     if orig_dict:
@@ -475,6 +519,8 @@ def _parse_response_for_dict_prefix(response, prefix):
 
 def _parse_response_for_dict_filter(response, filter):
     ''' Extracts name-values for names in filter from response header. Filter out the standard http headers.'''
+    if response is None:
+        return None
     return_dict = {}    
     orig_dict = _parse_response_for_dict(response)
     if orig_dict: