Error Handling

TMDbLib/Client/TMDbClient.cs

@@ -73,6 +73,12 @@ public TMDbConfig Config
 
         public bool HasConfig { get; private set; }
 
+        public bool ThrowExceptionsOnNotFound
+        {
+            get { return _client.ThrowExceptionsOnNotFound; }
+            set { _client.ThrowExceptionsOnNotFound = value; }
+        }
+
         /// <summary>
         /// The maximum number of times a call to TMDb will be retried
         /// </summary>
@@ -101,7 +107,7 @@ public int MaxRetryCount
         /// <remarks>
         /// The Web Proxy is optional. If set, every request will be sent through it.
         /// Use the constructor for setting it.
-        /// 
+        ///
         /// For convenience, this library also offers a <see cref="IWebProxy"/> implementation.
         /// Check <see cref="Utilities.TMDbAPIProxy"/> for more information.
         /// </remarks>

TMDbLib/Client/TMDbClientMovies.cs

@@ -101,7 +101,7 @@ public partial class TMDbClient
             RestResponse<Movie> response = await req.ExecuteGet<Movie>(cancellationToken).ConfigureAwait(false);
 
             // No data to patch up so return
-            if (response == null) return null;
+            if (response == null || !response.IsValid) return null;
 
             Movie item = await response.GetDataObject().ConfigureAwait(false);
 
@@ -172,7 +172,7 @@ public partial class TMDbClient
             return await GetMovieMethod<KeywordsContainer>(movieId, MovieMethods.Keywords, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<Movie> GetMovieLatestAsync( CancellationToken cancellationToken = default(CancellationToken))
+        public async Task<Movie> GetMovieLatestAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
             RestRequest req = _client.Create("movie/latest");
             RestResponse<Movie> resp = await req.ExecuteGet<Movie>(cancellationToken).ConfigureAwait(false);
@@ -382,5 +382,4 @@ private async Task<T> GetMovieMethod<T>(int movieId, MovieMethods movieMethod, s
             return item.StatusCode == 1 || item.StatusCode == 12;
         }
     }
-}
-
+}

TMDbLib/Objects/Exceptions/APIException.cs

@@ -0,0 +1,12 @@
+namespace TMDbLib.Objects.Exceptions
+{
+    public class APIException : TMDbException
+    {
+        public TMDbStatusMessage StatusMessage { get; }
+
+        public APIException(string message, TMDbStatusMessage statusMessage) : base(message)
+        {
+            StatusMessage = statusMessage;
+        }
+    }
+}

TMDbLib/Objects/Exceptions/GeneralHttpException.cs

@@ -0,0 +1,15 @@
+using System.Net;
+
+namespace TMDbLib.Objects.Exceptions
+{
+    public class GeneralHttpException : TMDbException
+    {
+        public HttpStatusCode HttpStatusCode { get; }
+
+        public GeneralHttpException(HttpStatusCode httpStatusCode)
+            : base("TMDb returned an unexpected HTTP error")
+        {
+            HttpStatusCode = httpStatusCode;
+        }
+    }
+}

TMDbLib/Objects/Exceptions/NotFoundException.cs

@@ -0,0 +1,10 @@
+namespace TMDbLib.Objects.Exceptions
+{
+    public class NotFoundException : APIException
+    {
+        public NotFoundException(TMDbStatusMessage statusMessage)
+                        : base("The requested item was not found", statusMessage)
+        {
+        }
+    }
+}

TMDbLib/Objects/Exceptions/RequestLimitExceededException.cs

@@ -2,14 +2,14 @@
 
 namespace TMDbLib.Objects.Exceptions
 {
-    public class RequestLimitExceededException : Exception
+    public class RequestLimitExceededException : APIException
     {
         public DateTimeOffset? RetryOn { get; }
 
         public TimeSpan? RetryAfter { get; }
 
-        internal RequestLimitExceededException(DateTimeOffset? retryOn, TimeSpan? retryAfter)
-            : base("You have exceeded the maximum number of request allowed by TMDb please try again later")
+        internal RequestLimitExceededException(TMDbStatusMessage statusMessage, DateTimeOffset? retryOn, TimeSpan? retryAfter)
+            : base("You have exceeded the maximum number of request allowed by TMDb please try again later", statusMessage)
         {
             RetryOn = retryOn;
             RetryAfter = retryAfter;

TMDbLib/Objects/Exceptions/TMDbException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace TMDbLib.Objects.Exceptions
+{
+    public class TMDbException : Exception
+    {
+        public TMDbException(string message)
+                : base(message)
+        {
+        }
+    }
+}

TMDbLib/Objects/Exceptions/TMDbStatusMessage.cs

@@ -0,0 +1,13 @@
+using Newtonsoft.Json;
+
+namespace TMDbLib.Objects.Exceptions
+{
+    public class TMDbStatusMessage
+    {
+        [JsonProperty("status_code")]
+        public int StatusCode { get; set; }
+
+        [JsonProperty("status_message")]
+        public string StatusMessage { get; set; }
+    }
+}

TMDbLib/Rest/RestClient.cs

@@ -45,6 +45,8 @@ public int MaxRetryCount
             }
         }
 
+        public bool ThrowExceptionsOnNotFound { get; set; }
+
         internal JsonSerializer Serializer { get; }
 
         public void AddDefaultQueryString(string key, string value)

TMDbLib/Rest/RestRequest.cs

@@ -42,8 +42,10 @@ public RestRequest AddParameter(string key, string value, ParameterType type = P
             {
                 case ParameterType.QueryString:
                     return AddQueryString(key, value);
+
                 case ParameterType.UrlSegment:
                     return AddUrlSegment(key, value);
+
                 default:
                     throw new ArgumentOutOfRangeException(nameof(type), type, null);
             }
@@ -84,63 +86,45 @@ private void AppendQueryString(StringBuilder sb, KeyValuePair<string, string> va
             AppendQueryString(sb, value.Key, value.Value);
         }
 
-        private void CheckResponse(HttpResponseMessage response)
-        {
-            if (response.StatusCode == HttpStatusCode.Unauthorized)
-                throw new UnauthorizedAccessException("Call to TMDb returned unauthorized. Most likely the provided API key is invalid.");
-        }
-
         public async Task<RestResponse> ExecuteDelete(CancellationToken cancellationToken)
         {
             HttpResponseMessage resp = await SendInternal(HttpMethod.Delete, cancellationToken).ConfigureAwait(false);
 
-            CheckResponse(resp);
-
             return new RestResponse(resp);
         }
 
         public async Task<RestResponse<T>> ExecuteDelete<T>(CancellationToken cancellationToken)
         {
             HttpResponseMessage resp = await SendInternal(HttpMethod.Delete, cancellationToken).ConfigureAwait(false);
 
-            CheckResponse(resp);
-
             return new RestResponse<T>(resp, _client);
         }
 
         public async Task<RestResponse> ExecuteGet(CancellationToken cancellationToken)
         {
             HttpResponseMessage resp = await SendInternal(HttpMethod.Get, cancellationToken).ConfigureAwait(false);
 
-            CheckResponse(resp);
-
             return new RestResponse(resp);
         }
 
         public async Task<RestResponse<T>> ExecuteGet<T>(CancellationToken cancellationToken)
         {
             HttpResponseMessage resp = await SendInternal(HttpMethod.Get, cancellationToken).ConfigureAwait(false);
 
-            CheckResponse(resp);
-
             return new RestResponse<T>(resp, _client);
         }
 
         public async Task<RestResponse> ExecutePost(CancellationToken cancellationToken)
         {
             HttpResponseMessage resp = await SendInternal(HttpMethod.Post, cancellationToken).ConfigureAwait(false);
 
-            CheckResponse(resp);
-
             return new RestResponse(resp);
         }
 
         public async Task<RestResponse<T>> ExecutePost<T>(CancellationToken cancellationToken)
         {
             HttpResponseMessage resp = await SendInternal(HttpMethod.Post, cancellationToken).ConfigureAwait(false);
 
-            CheckResponse(resp);
-
             return new RestResponse<T>(resp, _client);
         }
 
@@ -201,13 +185,21 @@ private async Task<HttpResponseMessage> SendInternal(HttpMethod method, Cancella
 
             Debug.Assert(timesToTry >= 1);
 
+            TMDbStatusMessage statusMessage = null;
+
             do
             {
                 using (HttpRequestMessage req = PrepRequest(method))
                 {
                     HttpResponseMessage resp =
                         await _client.HttpClient.SendAsync(req, cancellationToken).ConfigureAwait(false);
 
+                    if (!resp.IsSuccessStatusCode)
+                    {
+                        statusMessage =
+                            JsonConvert.DeserializeObject<TMDbStatusMessage>(await resp.Content.ReadAsStringAsync());
+                    }
+
                     if (resp.StatusCode == (HttpStatusCode)429)
                     {
                         // The previous result was a ratelimit, read the Retry-After header and wait the allotted time
@@ -227,12 +219,30 @@ private async Task<HttpResponseMessage> SendInternal(HttpMethod method, Cancella
                         return resp;
 
                     if (!resp.IsSuccessStatusCode)
-                        return resp;
+                    {
+                        switch (resp.StatusCode)
+                        {
+                            case HttpStatusCode.Unauthorized:
+                                throw new UnauthorizedAccessException("Call to TMDb returned unauthorized. Most likely the provided API key is invalid.");
+
+                            case HttpStatusCode.NotFound:
+                                if (_client.ThrowExceptionsOnNotFound)
+                                {
+                                    throw new NotFoundException(statusMessage);
+                                }
+                                else
+                                {
+                                    return null;
+                                }
+                        }
+                        throw new GeneralHttpException(resp.StatusCode);
+                        //return resp;
+                    }
                 }
             } while (timesToTry-- > 0);
 
             // We never reached a success
-            throw new RequestLimitExceededException(retryHeader?.Date, retryHeader?.Delta);
+            throw new RequestLimitExceededException(statusMessage, retryHeader?.Date, retryHeader?.Delta);
         }
 
         public RestRequest SetBody(object obj)

TMDbLib/Rest/RestResponse.cs

@@ -17,6 +17,8 @@ public RestResponse(HttpResponseMessage response)
             Response = response;
         }
 
+        public bool IsValid { get { return Response != null; } }
+
         public HttpStatusCode StatusCode => Response.StatusCode;
 
         public async Task<Stream> GetContent()
@@ -53,7 +55,14 @@ public static implicit operator T(RestResponse<T> response)
         {
             try
             {
-                return response.GetDataObject().Result;
+                if (response.IsValid)
+                {
+                    return response.GetDataObject().Result;
+                }
+                else
+                {
+                    return default(T);
+                }
             }
             catch (AggregateException ex)
             {

TMDbLibTests/ClientCreditTests.cs

@@ -33,6 +33,14 @@ public void TestGetCreditTv()
             Assert.Equal("", result.Media.Character);
         }
 
+        [Fact]
+        public void TestMissingCredit()
+        {
+            Credit result = Config.Client.GetCreditsAsync("9999999999").Result;
+
+            Assert.Null(result);
+        }
+
         [Fact]
         public void TestGetCreditEpisode()
         {

TMDbLibTests/ClientMovieTests.cs

@@ -216,7 +216,6 @@ public void TestMoviesGetMovieCasts()
             Assert.Equal("Music", crew.Job);
             Assert.Equal("Marco Beltrami", crew.Name);
             Assert.True(TestImagesHelpers.TestImagePath(crew.ProfilePath), "crew.ProfilePath was not a valid image path, was: " + crew.ProfilePath);
-
         }
 
         [Fact]
@@ -437,6 +436,16 @@ public void TestMoviesGetMovieChanges()
                 }
         }
 
+        [Fact]
+        public void TestMoviesMissing()
+        {
+            Movie movie1 = Config.Client.GetMovieAsync(999999999).Result;
+            Assert.Null(movie1);
+
+            Movie movie2 = Config.Client.GetMovieAsync(230).Result;
+            Assert.Null(movie2);
+        }
+
         [Fact]
         public void TestMoviesImages()
         {
@@ -836,4 +845,4 @@ public void TestMoviesExtrasAccountState()
             Assert.True(Math.Abs(movie.AccountStates.Rating.Value - 5) < double.Epsilon);
         }
     }
-}
+}