feat: produce a typed HTTP exception (influxdata#186)

Author: bednar

CHANGELOG.md

@@ -3,6 +3,7 @@
 ### Features
 1. [#184](https://github.com/influxdata/influxdb-client-csharp/pull/184): Add possibility to specify `WebProxy` for Client
 1. [#185](https://github.com/influxdata/influxdb-client-csharp/pull/185): Use `group()` function in output Flux query. See details - [Group function](/Client.Linq/README.md#group-function) [LINQ]
+1. [#186](https://github.com/influxdata/influxdb-client-csharp/pull/186): Produce a typed HTTP exception
 
 ### Bug Fixes
 1. [#183](https://github.com/influxdata/influxdb-client-csharp/pull/183): Propagate runtime exception to EventHandler

Client.Core.Test/AbstractMockServerTest.cs

@@ -38,11 +38,11 @@ public void ShutdownServer()
  MockServer?.Stop();
  }
 
- protected IResponseBuilder CreateErrorResponse(string influxDbError)
+ protected IResponseBuilder CreateErrorResponse(string influxDbError, int statusCode = 500)
  {
  var body = "{\"error\":\"" + influxDbError + "\"}";
 
- return Response.Create().WithStatusCode(500)
+ return Response.Create().WithStatusCode(statusCode)
  .WithHeader("X-Influx-Error", influxDbError)
  .WithBody(body);
  }

Client.Core.Test/HttpExceptionTest.cs

@@ -0,0 +1,39 @@
+using System.Net;
+using InfluxDB.Client.Core.Exceptions;
+using NUnit.Framework;
+using RestSharp;
+
+namespace InfluxDB.Client.Core.Test
+{
+ [TestFixture]
+ public class HttpExceptionTest
+ {
+ [Test]
+ public void ExceptionTypes()
+ {
+ Assert.IsInstanceOf(typeof(BadRequestException), HttpException.Create(Response(400), ""));
+ Assert.IsInstanceOf(typeof(UnauthorizedException), HttpException.Create(Response(401), ""));
+ Assert.IsInstanceOf(typeof(PaymentRequiredException), HttpException.Create(Response(402), ""));
+ Assert.IsInstanceOf(typeof(ForbiddenException), HttpException.Create(Response(403), ""));
+ Assert.IsInstanceOf(typeof(NotFoundException), HttpException.Create(Response(404), ""));
+ Assert.IsInstanceOf(typeof(MethodNotAllowedException), HttpException.Create(Response(405), ""));
+ Assert.IsInstanceOf(typeof(NotAcceptableException), HttpException.Create(Response(406), ""));
+ Assert.IsInstanceOf(typeof(ProxyAuthenticationRequiredException), HttpException.Create(Response(407), ""));
+ Assert.IsInstanceOf(typeof(RequestTimeoutException), HttpException.Create(Response(408), ""));
+ Assert.IsInstanceOf(typeof(RequestEntityTooLargeException), HttpException.Create(Response(413), ""));
+ Assert.IsInstanceOf(typeof(UnprocessableEntityException), HttpException.Create(Response(422), ""));
+ Assert.IsInstanceOf(typeof(TooManyRequestsException), HttpException.Create(Response(429), ""));
+ Assert.IsInstanceOf(typeof(InternalServerErrorException), HttpException.Create(Response(500), ""));
+ Assert.IsInstanceOf(typeof(HttpNotImplementedException), HttpException.Create(Response(501), ""));
+ Assert.IsInstanceOf(typeof(BadGatewayException), HttpException.Create(Response(502), ""));
+ Assert.IsInstanceOf(typeof(ServiceUnavailableException), HttpException.Create(Response(503), ""));
+ Assert.IsInstanceOf(typeof(HttpException), HttpException.Create(Response(550), ""));
+ Assert.IsInstanceOf(typeof(HttpException), HttpException.Create(Response(390), ""));
+ }
+
+ private static HttpResponse Response(int statusCode)
+ {
+ return new HttpResponse {StatusCode = (HttpStatusCode) statusCode};
+ }
+ }
+}

Client.Core/Exceptions/InfluxException.cs

@@ -126,8 +126,191 @@ public static HttpException Create(object content, IList<HttpHeader> headers, st
  if (string.IsNullOrEmpty(errorMessage)) errorMessage = ErrorMessage;
  if (string.IsNullOrEmpty(errorMessage)) errorMessage = stringBody;
 
- return new HttpException(errorMessage, (int) statusCode, exception)
- {ErrorBody = errorBody, RetryAfter = retryAfter};
+ var err = (int) statusCode switch
+ {
+ 400 => new BadRequestException(errorMessage, exception),
+ 401 => new UnauthorizedException(errorMessage, exception),
+ 402 => new PaymentRequiredException(errorMessage, exception),
+ 403 => new ForbiddenException(errorMessage, exception),
+ 404 => new NotFoundException(errorMessage, exception),
+ 405 => new MethodNotAllowedException(errorMessage, exception),
+ 406 => new NotAcceptableException(errorMessage, exception),
+ 407 => new ProxyAuthenticationRequiredException(errorMessage, exception),
+ 408 => new RequestTimeoutException(errorMessage, exception),
+ 413 => new RequestEntityTooLargeException(errorMessage, exception),
+ 422 => new UnprocessableEntityException(errorMessage, exception),
+ 429 => new TooManyRequestsException(errorMessage, exception),
+ 500 => new InternalServerErrorException(errorMessage, exception),
+ 501 => new HttpNotImplementedException(errorMessage, exception),
+ 502 => new BadGatewayException(errorMessage, exception),
+ 503 => new ServiceUnavailableException(errorMessage, exception),
+ _ => new HttpException(errorMessage, (int) statusCode, exception)
+ };
+
+ err.ErrorBody = errorBody;
+ err.RetryAfter = retryAfter;
+
+ return err;
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 400 - Bad Request.
+ /// </summary>
+ public class BadRequestException : HttpException
+ {
+ public BadRequestException(string message, Exception exception = null) : base(message, 400, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 401 - Unauthorized.
+ /// </summary>
+ public class UnauthorizedException : HttpException
+ {
+ public UnauthorizedException(string message, Exception exception = null) : base(message, 401, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 402 - Payment Required.
+ /// </summary>
+ public class PaymentRequiredException : HttpException
+ {
+ public PaymentRequiredException(string message, Exception exception = null) : base(message, 402, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 403 - Forbidden.
+ /// </summary>
+ public class ForbiddenException : HttpException
+ {
+ public ForbiddenException(string message, Exception exception = null) : base(message, 403, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 404 - Not Found.
+ /// </summary>
+ public class NotFoundException : HttpException
+ {
+ public NotFoundException(string message, Exception exception = null) : base(message, 404, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 405 - Method Not Allowed.
+ /// </summary>
+ public class MethodNotAllowedException : HttpException
+ {
+ public MethodNotAllowedException(string message, Exception exception = null) : base(message, 405, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 406 - Not Acceptable.
+ /// </summary>
+ public class NotAcceptableException : HttpException
+ {
+ public NotAcceptableException(string message, Exception exception = null) : base(message, 406, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 407 - Proxy Authentication Required.
+ /// </summary>
+ public class ProxyAuthenticationRequiredException : HttpException
+ {
+ public ProxyAuthenticationRequiredException(string message, Exception exception = null) : base(message, 407, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 408 - Request Timeout.
+ /// </summary>
+ public class RequestTimeoutException : HttpException
+ {
+ public RequestTimeoutException(string message, Exception exception = null) : base(message, 408, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 413 - Request Entity Too Large.
+ /// </summary>
+ public class RequestEntityTooLargeException : HttpException
+ {
+ public RequestEntityTooLargeException(string message, Exception exception = null) : base(message, 413, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 422 - Unprocessable Entity.
+ /// </summary>
+ public class UnprocessableEntityException : HttpException
+ {
+ public UnprocessableEntityException(string message, Exception exception = null) : base(message, 422, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 429 - Too Many Requests.
+ /// </summary>
+ public class TooManyRequestsException : HttpException
+ {
+ public TooManyRequestsException(string message, Exception exception = null) : base(message, 429, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 500 - Internal Server Error.
+ /// </summary>
+ public class InternalServerErrorException : HttpException
+ {
+ public InternalServerErrorException(string message, Exception exception = null) : base(message, 500, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 501 - Not Implemented.
+ /// </summary>
+ public class HttpNotImplementedException : HttpException
+ {
+ public HttpNotImplementedException(string message, Exception exception = null) : base(message, 501, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 502 - Bad Gateway.
+ /// </summary>
+ public class BadGatewayException : HttpException
+ {
+ public BadGatewayException(string message, Exception exception = null) : base(message, 502, exception)
+ {
+ }
+ }
+
+ /// <summary>
+ /// The exception for response: HTTP 503 - Service Unavailable.
+ /// </summary>
+ public class ServiceUnavailableException : HttpException
+ {
+ public ServiceUnavailableException(string message, Exception exception = null) : base(message, 503, exception)
+ {
  }
  }
 }

Client.Test/InfluxDbClientTest.cs

@@ -5,6 +5,7 @@
 using InfluxDB.Client.Api.Client;
 using InfluxDB.Client.Api.Domain;
 using InfluxDB.Client.Core;
+using InfluxDB.Client.Core.Exceptions;
 using InfluxDB.Client.Core.Test;
 using NUnit.Framework;
 using WireMock.RequestBuilders;
@@ -222,5 +223,18 @@ public void TrailingSlashInUrl()
  StringAssert.StartsWith(MockServerUrl + "/api/v2/", logEntry.RequestMessage.AbsoluteUrl);
  }
  }
+ 
+ [Test]
+ public void ProduceTypedException()
+ {
+ MockServer
+ .Given(Request.Create().UsingGet())
+ .RespondWith(CreateErrorResponse("unauthorized", 401));
+
+ var ioe = Assert.ThrowsAsync<UnauthorizedException>(async () =>
+ await _client.GetAuthorizationsApi().FindAuthorizationByIdAsync("id"));
+
+ Assert.AreEqual("unauthorized", ioe.Message);
+ }
  }
 }

Client.Test/ItAuthorizationsApiTest.cs

@@ -136,7 +136,7 @@ public async Task FindAuthorizationsById()
  [Test]
  public void FindAuthorizationsByIdNull()
  {
- var ioe = Assert.ThrowsAsync<HttpException>(async () =>
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () =>
  await _authorizationsApi.FindAuthorizationByIdAsync("020f755c3c082000"));
 
  Assert.AreEqual("authorization not found", ioe.Message);
@@ -154,7 +154,7 @@ public async Task DeleteAuthorization()
  // delete authorization
  await _authorizationsApi.DeleteAuthorizationAsync(createdAuthorization);
 
- var ioe = Assert.ThrowsAsync<HttpException>(async () =>
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () =>
  await _authorizationsApi.FindAuthorizationByIdAsync(createdAuthorization.Id));
 
  Assert.AreEqual("authorization not found", ioe.Message);
@@ -206,11 +206,11 @@ public async Task CloneAuthorization()
  [Test]
  public void CloneAuthorizationNotFound()
  {
- var ioe = Assert.ThrowsAsync<HttpException>(async () =>
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () =>
  await _authorizationsApi.CloneAuthorizationAsync("020f755c3c082000"));
 
  Assert.AreEqual("authorization not found", ioe.Message);
- Assert.AreEqual(typeof(HttpException), ioe.GetType());
+ Assert.AreEqual(typeof(NotFoundException), ioe.GetType());
  }
 
  private List<Permission> NewPermissions()

Client.Test/ItBucketsApiTest.cs

@@ -65,7 +65,7 @@ public async Task CloneBucket()
  [Test]
  public void CloneBucketNotFound()
  {
- var ioe = Assert.ThrowsAsync<HttpException>(async () =>
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () =>
  await _bucketsApi.CloneBucketAsync(GenerateName("bucket"), "020f755c3c082000"));
 
  Assert.AreEqual("bucket not found", ioe.Message);
@@ -117,7 +117,7 @@ public async Task DeleteBucket()
  // delete task
  await _bucketsApi.DeleteBucketAsync(createBucket);
 
- var ioe = Assert.ThrowsAsync<HttpException>(async () => await _bucketsApi.FindBucketByIdAsync(createBucket.Id));
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () => await _bucketsApi.FindBucketByIdAsync(createBucket.Id));
 
  Assert.AreEqual("bucket not found", ioe.Message);
  }
@@ -142,7 +142,7 @@ public async Task FindBucketById()
  [Test]
  public void FindBucketByIdNull()
  {
- var ioe = Assert.ThrowsAsync<HttpException>(async () =>
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () =>
  await _bucketsApi.FindBucketByIdAsync("020f755c3c082000"));
 
  Assert.AreEqual("bucket not found", ioe.Message);

Client.Test/ItChecksApiTest.cs

@@ -174,7 +174,7 @@ public void UpdateCheckNotExists()
  var update = new CheckPatch(name: "not exits name", description: "not exists update",
  status: CheckPatch.StatusEnum.Active);
 
- var ioe = Assert.ThrowsAsync<HttpException>(async () => await _checksApi
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () => await _checksApi
  .UpdateCheckAsync("020f755c3c082000", update));
 
  Assert.AreEqual("check not found for key \"020f755c3c082000\"", ioe.Message);
@@ -198,7 +198,7 @@ public async Task DeleteCheck()
 
  await _checksApi.DeleteCheckAsync(found);
 
- var ioe = Assert.ThrowsAsync<HttpException>(async () => await _checksApi
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () => await _checksApi
  .FindCheckByIdAsync("020f755c3c082000"));
 
  Assert.AreEqual("check not found for key \"020f755c3c082000\"", ioe.Message);
@@ -207,7 +207,7 @@ public async Task DeleteCheck()
  [Test]
  public void DeleteCheckNotFound()
  {
- var ioe = Assert.ThrowsAsync<HttpException>(async () => await _checksApi
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () => await _checksApi
  .DeleteCheckAsync("020f755c3c082000"));
 
  Assert.AreEqual("check not found for key \"020f755c3c082000\"", ioe.Message);
@@ -235,7 +235,7 @@ public async Task FindCheckById()
  [Test]
  public void FindCheckByIdNotFound()
  {
- var ioe = Assert.ThrowsAsync<HttpException>(async () => await _checksApi
+ var ioe = Assert.ThrowsAsync<NotFoundException>(async () => await _checksApi
  .FindCheckByIdAsync("020f755c3c082000"));
 
  Assert.AreEqual("check not found for key \"020f755c3c082000\"", ioe.Message);

Client.Test/ItInfluxDBClientTest.cs

@@ -98,7 +98,7 @@ public void OnBoardingAlreadyDone()
  {
  var onboarding = new OnboardingRequest("admin", "11111111", "Testing", "test");
 
- var ex = Assert.ThrowsAsync<HttpException>(async () => await Client.OnboardingAsync(onboarding));
+ var ex = Assert.ThrowsAsync<UnprocessableEntityException>(async () => await Client.OnboardingAsync(onboarding));
 
  Assert.AreEqual("onboarding has already been completed", ex.Message);
  Assert.AreEqual(422, ex.Status);