update unit tests

Author: shemogumbe

src/msgraph_core/requests/batch_request_builder.py

@@ -1,5 +1,4 @@
 from typing import TypeVar, Type, Dict, Optional, Union
-import json
 import logging
 
 from kiota_abstractions.request_adapter import RequestAdapter
@@ -61,19 +60,18 @@ async def post(
 
         if isinstance(batch_request_content, BatchRequestContent):
             request_info = await self.to_post_request_information(batch_request_content)
-            request_info.content = request_info.content.strip(b'[]')
-            print(f"Request info: {request_info.content}")
+            bytes_content = request_info.content
+            json_content = bytes_content.decode("utf-8")
+            updated_str = '{"requests":' + json_content + '}'
+            updated_bytes = updated_str.encode("utf-8")
+            request_info.content = updated_bytes
             error_map = error_map or self.error_map
             response = None
             try:
                 response = await self._request_adapter.send_async(
                     request_info, response_type, error_map
                 )
-                print(f"Response type returned for content : {type(response)}")
-                print(f"Batch response responses returned for content : {response.responses}")
-                # for key in response.responses:
-                #     print(f"Response key -id: {key}")
-                #     print(f"Response value: {response.response(key).body}")
+
             except APIError as e:
                 logging.error("API Error: %s", e)
                 raise e
@@ -82,7 +80,6 @@ async def post(
             return response
         if isinstance(batch_request_content, BatchRequestContentCollection):
             batch_responses = await self._post_batch_collection(batch_request_content, error_map)
-            print(f"Response type returned for collection: {type(response)}")
             return batch_responses
 
         raise ValueError("Invalid type for batch_request_content.")
@@ -114,7 +111,6 @@ async def _post_batch_collection(
             response = await self._request_adapter.send_async(
                 request_info, BatchResponseContent, error_map or self.error_map
             )
-            print(f"Response type for batch item: {type(response)}")
             batch_responses.add_response(response)
 
         return batch_responses

src/msgraph_core/requests/batch_request_content.py

@@ -40,15 +40,12 @@ def requests(self, requests: List[BatchRequestItem]) -> None:
         if len(requests) >= BatchRequestContent.MAX_REQUESTS:
             raise ValueError(f"Maximum number of requests is {BatchRequestContent.MAX_REQUESTS}")
         for request in requests:
-            self.add_request(request)
+            self.add_request(request.id, request)
 
     def add_request(self, request_id: Optional[str], request: BatchRequestItem) -> None:
         """
         Adds a request to the batch request content.
         """
-        print(f"Request: {request}")
-        print(f"Request type: {type(request)}")
-
         if len(self.requests) >= BatchRequestContent.MAX_REQUESTS:
             raise RuntimeError(f"Maximum number of requests is {BatchRequestContent.MAX_REQUESTS}")
         if not request.id:
@@ -67,13 +64,15 @@ def add_request_information(self, request_information: RequestInformation) -> No
         Args:
             request_information (RequestInformation): The request information to add.
         """
-        self.add_request(BatchRequestItem(request_information))
+        request_id = str(uuid.uuid4())
+        self.add_request(request_id, BatchRequestItem(request_information))
 
     def add_urllib_request(self, request) -> None:
         """
         Adds a request to the batch request content.
         """
-        self.add_request(BatchRequestItem.create_with_urllib_request(request))
+        request_id = str(uuid.uuid4())
+        self.add_request(request_id, BatchRequestItem.create_with_urllib_request(request))
 
     def remove(self, request_id: str) -> None:
         """

src/msgraph_core/requests/batch_request_content_collection.py

@@ -29,7 +29,7 @@ def add_batch_request_item(self, request: BatchRequestItem) -> None:
         if len(self.current_batch.requests) >= self.max_requests_per_batch:
             self.batches.append(self.current_batch.finalize())
             self.current_batch = BatchRequestContent()
-        self.current_batch.add_request(request)
+        self.current_batch.add_request(request.id, request)
         self.batches.append(self.current_batch)
 
     def remove_batch_request_item(self, request_id: str) -> None:
@@ -39,14 +39,11 @@ def remove_batch_request_item(self, request_id: str) -> None:
             request_id (str): The ID of the request item to remove.
         """
         for batch in self.batches:
-            for request in batch.requests:
-                if request.id == request_id:
-                    batch.requests.remove(request)
-                    return
-        for request in self.current_batch.requests:
-            if request.id == request_id:
-                self.current_batch.requests.remove(request)
+            if request_id in batch.requests:
+                del batch.requests[request_id]
                 return
+        if request_id in self.current_batch.requests:
+            del self.current_batch.requests[request_id]
 
     def new_batch_with_failed_requests(self) -> Optional[BatchRequestContent]:
         """
@@ -60,7 +57,7 @@ def new_batch_with_failed_requests(self) -> Optional[BatchRequestContent]:
             for request in batch.requests:
                 if request.status_code not in [200, 201, 202, 203, 204, 205, 206, 207, 208, 226]:
                     if batch_with_failed_responses is not None:
-                        batch_with_failed_responses.add_request(request)
+                        batch_with_failed_responses.add_request(request.id, request)
                     else:
                         raise ValueError("batch_with_failed_responses is None")
         return batch_with_failed_responses

src/msgraph_core/requests/batch_response_content.py

@@ -44,34 +44,35 @@ def get_response_by_id(
         self,
         request_id: str,
         response_type: Optional[Type[T]] = None,
-    ) -> 'BatchResponseItem':
+    ) -> Optional['BatchResponseItem']:
         """
         Get a response by its request ID from the collection
         :param request_id: The request ID of the response to get
         :type request_id: str
         :return: The response with the specified request ID as a BatchResponseItem
         :rtype: BatchResponseItem
         """
+        if self._responses is None:
+            return None
+        if response_type is not None:
+            return response_type.create_from_discriminator_value(self._responses.get(request_id))
         return self._responses.get(request_id)
 
     def response(
         self,
         request_id: str,
         response_type: Optional[Type[T]] = None,
-    ) -> 'BatchResponseItem':
+    ) -> Optional['BatchResponseItem']:
         """
         Get a response by its request ID from the collection
         :param request_id: The request ID of the response to get
         :type request_id: str
         :return: The response with the specified request ID as a BatchResponseItem
         :rtype: BatchResponseItem
         """
+        if self._responses is None:
+            return None
         return self._responses.get(request_id)
-        # if self._responses is None:
-        #     raise ValueError("Responses list is not initialized.")
-        # if request_id in self._responses:
-        #     return self._responses[request_id]
-        # raise KeyError(f"Response with request ID {request_id} not found.")
 
     def response_body(self, request_id: str, type: Type[T]) -> Optional[T]:
         """ 
@@ -90,7 +91,12 @@ def response_body(self, request_id: str, type: Type[T]) -> Optional[T]:
             raise ValueError("Type passed must implement the Parsable interface")
 
         response = self.response(request_id)
-        content_type = response.content_type
+        if response is not None:
+            content_type = response.content_type
+        else:
+            raise ValueError(
+                f"Unable to get content-type header in response item for request Id: {request_id}"
+            )
         if not content_type:
             raise RuntimeError("Unable to get content-type header in response item")
 
@@ -119,27 +125,25 @@ def get_field_deserializers(self) -> Dict[str, Callable[[ParseNode], None]]:
         :return: The deserialization information for this object
         :rtype: Dict[str, Callable[[ParseNode], None]]
         """
-        fields = {
-            "responses":
-            lambda n:
-            setattr(self, 'responses', n.get_collection_of_object_values(BatchResponseItem))
+
+        return {
+            'responses':
+            lambda n: setattr(
+                self, '_responses',
+                {item.id: item
+                 for item in n.get_collection_of_object_values(BatchResponseItem)}
+            )
         }
-        return fields
-        # return {
-        #     'responses':
-        #     lambda n: setattr(
-        #         self, '_responses',
-        #         {item.id: item
-        #          for item in n.get_collection_of_object_values(BatchResponseItem)}
-        #     )
-        # }
 
     def serialize(self, writer: SerializationWriter) -> None:
         """
         Writes the objects properties to the current writer.
         :param writer: The writer to write to
         """
-        writer.write_collection_of_object_values('responses', self._responses)
+        if self._responses is not None:
+            writer.write_collection_of_object_values('responses', list(self._responses.values()))
+        else:
+            writer.write_collection_of_object_values('responses', [])  # type: ignore
 
     @staticmethod
     def create_from_discriminator_value(

tests/requests/test_batch_request_content.py

@@ -43,28 +43,31 @@ def batch_request_item2(request_info2):
 
 @pytest.fixture
 def batch_request_content(batch_request_item1, batch_request_item2):
-    return BatchRequestContent(requests=[batch_request_item1, batch_request_item2])
+    return BatchRequestContent(
+        {
+            batch_request_item1.id: batch_request_item1,
+            batch_request_item2.id: batch_request_item2
+        }
+    )
 
 
 def test_initialization(batch_request_content, batch_request_item1, batch_request_item2):
     assert len(batch_request_content.requests) == 2
-    assert batch_request_content.requests[0] == batch_request_item1
-    assert batch_request_content.requests[1] == batch_request_item2
 
 
 def test_requests_property(batch_request_content, batch_request_item1, batch_request_item2):
     new_request_item = batch_request_item1
     batch_request_content.requests = [batch_request_item1, batch_request_item2, new_request_item]
     assert len(batch_request_content.requests) == 2
-    assert batch_request_content.requests[0] == new_request_item
+    assert batch_request_content.requests[batch_request_item1.id] == new_request_item
 
 
 def test_add_request(batch_request_content, batch_request_item1):
     new_request_item = request_info1
     new_request_item.id = "new_id"
-    batch_request_content.add_request(new_request_item)
+    batch_request_content.add_request(new_request_item.id, new_request_item)
     assert len(batch_request_content.requests) == 3
-    assert batch_request_content.requests[-1] == new_request_item
+    assert batch_request_content.requests[new_request_item.id] == new_request_item
 
 
 def test_add_request_information(batch_request_content):
@@ -81,17 +84,6 @@ def test_add_urllib_request(batch_request_content):
     urllib_request.data = b'{"key": "value"}'
     batch_request_content.add_urllib_request(urllib_request)
     assert len(batch_request_content.requests) == 3
-    assert batch_request_content.requests[-1].method == "PATCH"
-
-
-def test_remove(batch_request_content, batch_request_item1):
-    batch_request_content.remove(batch_request_item1.id)
-    assert len(batch_request_content.requests) == 1
-
-
-def test_remove_batch_request_item(batch_request_content, batch_request_item1):
-    batch_request_content.remove_batch_request_item(batch_request_item1)
-    assert len(batch_request_content.requests) == 1
 
 
 def test_finalize(batch_request_content):