write tests for response models

src/msgraph_core/requests/batch_response_item.py

@@ -65,7 +65,7 @@ def status(self) -> Optional[int]:
  :return: The status code of the response
  :rtype: Optional[int]
  """
- return self._status_code
+ return self._status
 
  @status.setter
  def status(self, status_code: Optional[int]) -> None:
@@ -74,7 +74,7 @@ def status(self, status_code: Optional[int]) -> None:
  :param status_code: The status code of the response
  :type status_code: Optional[int]
  """
- self._status_code = status_code
+ self._status = status_code
 
  @property
  def headers(self) -> Optional[Dict[str, str]]:
@@ -157,6 +157,6 @@ def serialize(self, writer: SerializationWriter) -> None:
  """
  writer.write_str_value('id', self._id)
  writer.write_str_value('atomicity_group', self._atomicity_group)
- writer.write_int_value('status_code', self._status_code)
+ writer.write_int_value('status', self._status)
  writer.write_collection_of_primitive_values('headers', self._headers)
  writer.write_bytes_value('body', self._body)

tests/requests/test_batch_response_content.py

@@ -0,0 +1,71 @@
+import pytest
+from unittest.mock import Mock
+from io import BytesIO
+from kiota_abstractions.serialization import ParseNode, SerializationWriter, Parsable, ParseNodeFactoryRegistry
+from msgraph_core.requests.batch_response_item import BatchResponseItem
+from msgraph_core.requests.batch_response_content import BatchResponseContent
+
+
+@pytest.fixture
+def batch_response_content():
+ return BatchResponseContent()
+
+
+def test_initialization(batch_response_content):
+ assert batch_response_content.responses == []
+
+
+def test_responses_property(batch_response_content):
+ response_item = Mock(spec=BatchResponseItem)
+ batch_response_content.responses = [response_item]
+ assert batch_response_content.responses == [response_item]
+
+
+def test_response_method(batch_response_content):
+ response_item = Mock(spec=BatchResponseItem)
+ response_item.request_id = "12345"
+ batch_response_content.responses = [response_item]
+ assert batch_response_content.response("12345") == response_item
+
+
+def test_get_response_by_id_method(batch_response_content):
+ response_item = Mock(spec=BatchResponseItem)
+ response_item.request_id = "12345"
+ batch_response_content.responses = [response_item]
+ assert batch_response_content.get_response_by_id("12345") == response_item
+
+
+def test_response_body_method(batch_response_content):
+ response_item = Mock(spec=BatchResponseItem)
+ response_item.request_id = "12345"
+ response_item.content_type = "application/json"
+ response_item.body = BytesIO(b'{"key": "value"}')
+ batch_response_content.responses = [response_item]
+
+ parse_node = Mock(spec=ParseNode)
+ parse_node.get_object_value.return_value = {"key": "value"}
+ registry = Mock(spec=ParseNodeFactoryRegistry)
+ registry.get_root_parse_node.return_value = parse_node
+
+ with pytest.raises(ValueError):
+ batch_response_content.response_body("12345", dict)
+
+
+def test_get_field_deserializers(batch_response_content):
+ deserializers = batch_response_content.get_field_deserializers()
+ assert isinstance(deserializers, dict)
+ assert "responses" in deserializers
+
+
+def test_serialize(batch_response_content):
+ writer = Mock(spec=SerializationWriter)
+ response_item = Mock(spec=BatchResponseItem)
+ batch_response_content.responses = [response_item]
+ batch_response_content.serialize(writer)
+ writer.write_collection_of_object_values.assert_called_once_with('responses', [response_item])
+
+
+def test_create_from_discriminator_value():
+ parse_node = Mock(spec=ParseNode)
+ batch_response_content = BatchResponseContent.create_from_discriminator_value(parse_node)
+ assert isinstance(batch_response_content, BatchResponseContent)

tests/requests/test_batch_response_item.py

@@ -0,0 +1,84 @@
+import pytest
+from io import BytesIO
+
+from kiota_abstractions.serialization import ParseNode, SerializationWriter
+from unittest.mock import Mock
+
+from msgraph_core.requests.batch_response_item import BatchResponseItem, StreamInterface
+
+
+@pytest.fixture
+def batch_response_item():
+ return BatchResponseItem()
+
+
+def test_initialization(batch_response_item):
+ assert batch_response_item.id is None
+ assert batch_response_item.atomicity_group is None
+ assert batch_response_item.status is None
+ assert batch_response_item.headers == {}
+ assert batch_response_item.body is None
+
+
+def test_id_property(batch_response_item):
+ batch_response_item.id = "12345"
+ assert batch_response_item.id == "12345"
+
+
+def test_atomicity_group_property(batch_response_item):
+ batch_response_item.atomicity_group = "group1"
+ assert batch_response_item.atomicity_group == "group1"
+
+
+def test_status_property(batch_response_item):
+ batch_response_item.status = 200
+ assert batch_response_item.status == 200
+
+
+def test_headers_property(batch_response_item):
+ headers = {"Content-Type": "application/json"}
+ batch_response_item.headers = headers
+ assert batch_response_item.headers == headers
+
+
+def test_body_property(batch_response_item):
+ body = StreamInterface(b"response body")
+ batch_response_item.body = body
+ assert batch_response_item.body == body
+
+
+def test_content_type_property(batch_response_item):
+ headers = {"Content-Type": "application/json"}
+ batch_response_item.headers = headers
+ assert batch_response_item.content_type == "application/json"
+
+
+def test_create_from_discriminator_value():
+ parse_node = Mock(spec=ParseNode)
+ batch_response_item = BatchResponseItem.create_from_discriminator_value(parse_node)
+ assert isinstance(batch_response_item, BatchResponseItem)
+
+
+def test_get_field_deserializers(batch_response_item):
+ deserializers = batch_response_item.get_field_deserializers()
+ assert isinstance(deserializers, dict)
+ assert "id" in deserializers
+ assert "status" in deserializers
+ assert "headers" in deserializers
+ assert "body" in deserializers
+
+
+def test_serialize(batch_response_item):
+ writer = Mock(spec=SerializationWriter)
+ batch_response_item.id = "12345"
+ batch_response_item.atomicity_group = "group1"
+ batch_response_item.status = 200
+ batch_response_item.headers = {"Content-Type": "application/json"}
+ batch_response_item.body = StreamInterface(b"response body")
+ batch_response_item.serialize(writer)
+ writer.write_str_value.assert_any_call('id', "12345")
+ writer.write_str_value.assert_any_call('atomicity_group', "group1")
+ writer.write_int_value.assert_any_call('status', 200)
+ writer.write_collection_of_primitive_values.assert_any_call(
+ 'headers', {"Content-Type": "application/json"}
+ )