fix: void type handling with return type creator (#77)

* fix: void type handling with return type creator

* adds the api response wrapping to empty responses where applicable

* add equality comparator

Author: asadali214

APIMatic.Core.Test/Api/HttpGet/ApiCallGetTest.cs

@@ -383,6 +383,33 @@ public void ApiCall_GetVoid()
             Assert.Null(actual);
         }
 
+        [Test]
+        public void ApiCall_GetVoid_WithApiResponse()
+        {
+            //Arrange
+            var url = "/apicall/get-void/api-response/200";
+
+            var content = JsonContent.Create("Test body");
+            handlerMock.When(GetCompleteUrl(url))
+                .With(req =>
+                {
+                    Assert.AreEqual(0, req.Headers.Accept.Count);
+                    return true;
+                })
+                .Respond(HttpStatusCode.OK, content);
+
+            var apiCall = CreateApiCall<VoidType>()
+                .RequestBuilder(requestBuilderAction => requestBuilderAction.Setup(HttpMethod.Get, url))
+                .ExecuteAsync();
+
+            // Act
+            ApiResponse<VoidType> actual = CoreHelper.RunTask(apiCall);
+
+            // Assert
+            Assert.AreEqual(200, actual.StatusCode);
+            Assert.Null(actual.Data);
+        }
+
         [Test]
         public void ApiCall_GetStream()
         {

APIMatic.Core/Response/ResponseHandler.cs

@@ -119,33 +119,29 @@ internal ReturnType Result<ReturnType>(CoreContext<CoreRequest, CoreResponse> co
                 {
                     return default;
                 }
+
                 throw ResponseError(context);
             }
-            if (HasEmptyResponse(context.Response))
-            {
-                return default;
-            }
+
             ResponseType result = ConvertResponse(context.Response);
             result = contextAdder(result, compatibilityFactory.CreateHttpContext(context.Request, context.Response));
-            if (result is ReturnType convertedResult)
-            {
-                return convertedResult;
-            }
+
             if (returnTypeCreator != null)
             {
                 return returnTypeCreator(compatibilityFactory.CreateHttpResponse(context.Response), result);
             }
-            throw new InvalidOperationException($"Unable to transform {typeof(ResponseType)} into {typeof(ReturnType)}. ReturnTypeCreator is not provided.");
-        }
 
-        private bool HasEmptyResponse(CoreResponse response)
-        {
-            var resType = typeof(ResponseType);
-            if (resType == typeof(VoidType))
+            if (EqualityComparer<ResponseType>.Default.Equals(result, default))
             {
-                return true;
+                return default;
             }
-            return string.Equals(response.Body?.Trim(), string.Empty) && CoreHelper.IsNullableType(resType);
+
+            if (result is ReturnType convertedResult)
+            {
+                return convertedResult;
+            }
+
+            throw new InvalidOperationException($"Unable to transform {typeof(ResponseType)} into {typeof(ReturnType)}. ReturnTypeCreator is not provided.");
         }
 
         private ApiException ResponseError(CoreContext<CoreRequest, CoreResponse> context)
@@ -206,6 +202,10 @@ private bool GetDefaultErrorCaseFromErrors(out ErrorCase<Request, Response, Cont
 
         private ResponseType ConvertResponse(CoreResponse response)
         {
+            if (HasEmptyResponse(response))
+            {
+                return default;
+            }
             if (response.RawBody is ResponseType streamResponse)
             {
                 return streamResponse;
@@ -216,5 +216,15 @@ private ResponseType ConvertResponse(CoreResponse response)
             }
             return deserializer(response.Body);
         }
+
+        private bool HasEmptyResponse(CoreResponse response)
+        {
+            var resType = typeof(ResponseType);
+            if (typeof(VoidType).IsAssignableFrom(resType))
+            {
+                return true;
+            }
+            return string.Equals(response.Body?.Trim(), string.Empty) && CoreHelper.IsNullableType(resType);
+        }
     }
 }