Merge pull request #46 from matteobortolazzo/dev

Matteo Bortolazzo · web-flow · commit 866e4da16442 · 2019-06-14T13:01:10.000+01:00
Release 1.1.3
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,9 @@
-﻿# 1.1.2 (2019-06-08)
+﻿# 1.1.3 (2019-06-14)
+
+## Bug Fixes
+* **Exception:** Fixing null reference exception and poor exception handling. ([#PR45](https://github.com/matteobortolazzo/couchdb-net/pull/45))
+
+# 1.1.2 (2019-06-08)
 
 ## Bug Fixes
 * **Client:** Prevent deadlocks when run against .NET Framework. ([#PR43](https://github.com/matteobortolazzo/couchdb-net/pull/43))
diff --git a/LATEST_CHANGE.md b/LATEST_CHANGE.md
@@ -1,2 +1,2 @@
 ﻿## Bug Fixes
-* **Client:** Prevent deadlocks when run against .NET Framework. ([#PR43](https://github.com/matteobortolazzo/couchdb-net/pull/43))
+* **Exception:** Fixing null reference exception and poor exception handling. ([#PR45](https://github.com/matteobortolazzo/couchdb-net/pull/45))
diff --git a/src/CouchDB.Driver/CouchQueryProvider.cs b/src/CouchDB.Driver/CouchQueryProvider.cs
@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.ExceptionServices;
 
 namespace CouchDB.Driver
 {
@@ -37,14 +38,22 @@ public override object Execute(Expression expression, bool completeResponse)
             // Remove from the expressions tree all IQueryable methods not supported by CouchDB and put them into the list
             var unsupportedMethodCallExpressions = new List<MethodCallExpression>();
             expression = RemoveUnsupportedMethodExpressions(expression, out var hasUnsupportedMethods, unsupportedMethodCallExpressions);
-            
+
             var body = Translate(ref expression);
             Type elementType = TypeSystem.GetElementType(expression.Type);
 
             // Create generic GetCouchList method and invoke it, sending the request to CouchDB
             MethodInfo method = typeof(CouchQueryProvider).GetMethod(nameof(CouchQueryProvider.GetCouchList));
             MethodInfo generic = method.MakeGenericMethod(elementType);
-            var result = generic.Invoke(this, new[] { body });
+            object result = null;
+            try
+            {
+                result = generic.Invoke(this, new[] { body });
+            }
+            catch (TargetInvocationException ex)
+            {
+                ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
+            }
 
             // If no unsupported methods, return the result
             if (!hasUnsupportedMethods)
@@ -73,7 +82,7 @@ private string Translate(ref Expression e)
         }
 
         public object GetCouchList<T>(string body)
-        {            
+        {
             FindResult<T> result = _flurlClient
                 .Request(_connectionString)
                 .AppendPathSegments(_db, "_find")
@@ -82,7 +91,7 @@ public object GetCouchList<T>(string body)
                 .SendRequest();
 
             var couchList = new CouchList<T>(result.Docs.ToList(), result.Bookmark, result.ExecutionStats);
-            return couchList;            
+            return couchList;
         }
 
         private Expression RemoveUnsupportedMethodExpressions(Expression expression, out bool hasUnsupportedMethods, IList<MethodCallExpression> unsupportedMethodCallExpressions)
@@ -177,7 +186,7 @@ MethodInfo FindEnumerableMethod()
                 throw;
             }
         }
-        
+
         private object GetArgumentValueFromExpression(Expression e)
         {
             if (e is ConstantExpression c)
@@ -190,7 +199,7 @@ private object GetArgumentValueFromExpression(Expression e)
             }
             throw new NotImplementedException($"Expression of type {e.NodeType} not supported.");
         }
-        
+
         private static MethodInfo FindEnumerableMinMax(MethodInfo queryableMethodInfo)
         {
             Type[] genericParams = queryableMethodInfo.GetGenericArguments();
@@ -203,6 +212,6 @@ private static MethodInfo FindEnumerableMinMax(MethodInfo queryableMethodInfo)
                     enumerableMethodInfo.ReturnType == genericParams[1];
             });
             return finalMethodInfo;
-        }           
+        }
     }
 }
diff --git a/src/CouchDB.Driver/Exceptions/CouchConflictException.cs b/src/CouchDB.Driver/Exceptions/CouchConflictException.cs
@@ -1,16 +1,14 @@
-﻿namespace CouchDB.Driver.Exceptions
+﻿using CouchDB.Driver.DTOs;
+using System;
+
+namespace CouchDB.Driver.Exceptions
 {
     /// <summary>
     /// The exception that is thrown when there is a conflict.
     /// </summary>
     public class CouchConflictException : CouchException
     {
-        /// <summary>
-        /// Creates a new instance of CouchConflictException.
-        /// </summary>
-        /// <param name="message">Error message</param>
-        /// <param name="reason">Error reason</param>
-        public CouchConflictException(string message, string reason) : base(message, reason) { }
+        internal CouchConflictException(CouchError couchError, Exception innerException) : base(couchError, innerException) { }
 
         public CouchConflictException()
         {
@@ -20,7 +18,7 @@ public CouchConflictException(string message) : base(message)
         {
         }
 
-        public CouchConflictException(string message, System.Exception innerException) : base(message, innerException)
+        public CouchConflictException(string message, Exception innerException) : base(message, innerException)
         {
         }
     }
diff --git a/src/CouchDB.Driver/Exceptions/CouchException.cs b/src/CouchDB.Driver/Exceptions/CouchException.cs
@@ -1,4 +1,5 @@
-﻿using System;
+﻿using CouchDB.Driver.DTOs;
+using System;
 
 namespace CouchDB.Driver.Exceptions
 {
@@ -12,18 +13,31 @@ public class CouchException : Exception
         /// </summary>
         /// <param name="message">Error message</param>
         /// <param name="reason">Error reason</param>
-        public CouchException(string message, string reason) : base(message, new Exception(reason)) { }
+        public CouchException(string message, string reason) : this(message, reason, null)
+        {
+        }
+
+        public CouchException() : this(null, null, null)
+        {
+        }
 
-        public CouchException()
+        public CouchException(string message) : this(message, null, null)
         {
         }
 
-        public CouchException(string message) : base(message)
+        public CouchException(string message, Exception innerException) : this(message, null, innerException)
         {
         }
 
-        public CouchException(string message, Exception innerException) : base(message, innerException)
+        internal CouchException(CouchError couchError, Exception innerException) : this(couchError?.Error, couchError?.Reason, innerException)
         {
         }
+
+        public CouchException(string message, string reason, Exception innerException) : base(message, innerException)
+        {
+            Reason = reason;
+        }
+
+        public string Reason { get; }
     }
 }
diff --git a/src/CouchDB.Driver/Exceptions/CouchNoIndexException.cs b/src/CouchDB.Driver/Exceptions/CouchNoIndexException.cs
@@ -1,16 +1,14 @@
-﻿namespace CouchDB.Driver.Exceptions
+﻿using CouchDB.Driver.DTOs;
+using System;
+
+namespace CouchDB.Driver.Exceptions
 {
     /// <summary>
     /// The exception that is thrown when there is no index for the query.
     /// </summary>
     public class CouchNoIndexException : CouchException
     {
-        /// <summary>
-        /// Creates a new instance of CouchNoIndexException.
-        /// </summary>
-        /// <param name="message">Error message</param>
-        /// <param name="reason">Error reason</param>
-        public CouchNoIndexException(string message, string reason) : base(message, reason) { }
+        internal CouchNoIndexException(CouchError couchError, Exception innerException) : base(couchError, innerException) { }
 
         public CouchNoIndexException()
         {
@@ -20,7 +18,7 @@ public CouchNoIndexException(string message) : base(message)
         {
         }
 
-        public CouchNoIndexException(string message, System.Exception innerException) : base(message, innerException)
+        public CouchNoIndexException(string message, Exception innerException) : base(message, innerException)
         {
         }
     }
diff --git a/src/CouchDB.Driver/Exceptions/CouchNotFoundException.cs b/src/CouchDB.Driver/Exceptions/CouchNotFoundException.cs
@@ -1,16 +1,14 @@
-﻿namespace CouchDB.Driver.Exceptions
+﻿using CouchDB.Driver.DTOs;
+using System;
+
+namespace CouchDB.Driver.Exceptions
 {
     /// <summary>
     /// The exception that is thrown when something is not found.
     /// </summary>
     public class CouchNotFoundException : CouchException
     {
-        /// <summary>
-        /// Creates a new instance of CouchNotFoundException.
-        /// </summary>
-        /// <param name="message">Error message</param>
-        /// <param name="reason">Error reason</param>
-        public CouchNotFoundException(string message, string reason) : base(message, reason) { }
+        internal CouchNotFoundException(CouchError couchError, Exception innerException) : base(couchError, innerException) { }
 
         public CouchNotFoundException()
         {
@@ -20,7 +18,7 @@ public CouchNotFoundException(string message) : base(message)
         {
         }
 
-        public CouchNotFoundException(string message, System.Exception innerException) : base(message, innerException)
+        public CouchNotFoundException(string message, Exception innerException) : base(message, innerException)
         {
         }
     }
diff --git a/src/CouchDB.Driver/Helpers/RequestsHelper.cs b/src/CouchDB.Driver/Helpers/RequestsHelper.cs
@@ -23,41 +23,25 @@ public static async Task<T> SendRequestAsync<T>(this Task<T> asyncRequest)
             }
             catch (FlurlHttpException ex)
             {
-                CouchError couchError;
-                try
-                {
-                    couchError = await ex.GetResponseJsonAsync<CouchError>().ConfigureAwait(false);
-                }
-                catch
+                CouchError couchError = await ex.GetResponseJsonAsync<CouchError>().ConfigureAwait(false);
+
+                if (couchError == null)
                 {
-                    throw;
+                    couchError = new CouchError();
                 }
 
-                if (couchError != null)
+                switch (ex.Call.HttpStatus)
                 {
-                    switch (ex.Call.HttpStatus)
-                    {
-                        case HttpStatusCode.Conflict:
-                            throw couchError.NewCouchExteption(typeof(CouchConflictException));
-                        case HttpStatusCode.NotFound:
-                            throw couchError.NewCouchExteption(typeof(CouchNotFoundException));
-                        case HttpStatusCode.BadRequest:
-                            if (couchError.Error == "no_usable_index")
-                            {
-                                throw couchError.NewCouchExteption(typeof(CouchNoIndexException));
-                            }
-                            break;
-                    }
+                    case HttpStatusCode.Conflict:
+                        throw new CouchConflictException(couchError, ex);
+                    case HttpStatusCode.NotFound:
+                        throw new CouchNotFoundException(couchError, ex);
+                    case HttpStatusCode.BadRequest when couchError.Error == "no_usable_index":
+                        throw new CouchNoIndexException(couchError, ex);
+                    default:
+                        throw new CouchException(couchError, ex);
                 }
-                throw new CouchException(couchError.Error, couchError.Reason);                
             }
         }
-
-        private static Exception NewCouchExteption(this CouchError e, Type type)
-        {
-            ConstructorInfo ctor = type.GetConstructor(new[] { typeof(string), typeof(string) });
-            var exception = (CouchException)ctor.Invoke(new string[] { e.Error, e.Reason });
-            return exception;
-        }
     }
 }
diff --git a/tests/CouchDB.Driver.UnitTests/Client_Tests.cs b/tests/CouchDB.Driver.UnitTests/Client_Tests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`## Bug Fixes`
`2`		`-* Client: Prevent deadlocks when run against .NET Framework. ([#PR43](https://github.com/matteobortolazzo/couchdb-net/pull/43))`
	`2`	`+* Exception: Fixing null reference exception and poor exception handling. ([#PR45](https://github.com/matteobortolazzo/couchdb-net/pull/45))`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,14 @@`
`1`		`-namespace CouchDB.Driver.Exceptions`
	`1`	`+using CouchDB.Driver.DTOs;`
	`2`	`+using System;`
	`3`	`+`
	`4`	`+namespace CouchDB.Driver.Exceptions`
`2`	`5`	`{`
`3`	`6`	`/// <summary>`
`4`	`7`	`/// The exception that is thrown when there is a conflict.`
`5`	`8`	`/// </summary>`
`6`	`9`	`public class CouchConflictException : CouchException`
`7`	`10`	`{`
`8`		`- /// <summary>`
`9`		`- /// Creates a new instance of CouchConflictException.`
`10`		`- /// </summary>`
`11`		`- /// <param name="message">Error message</param>`
`12`		`- /// <param name="reason">Error reason</param>`
`13`		`- public CouchConflictException(string message, string reason) : base(message, reason) { }`
	`11`	`+ internal CouchConflictException(CouchError couchError, Exception innerException) : base(couchError, innerException) { }`
`14`	`12`
`15`	`13`	`public CouchConflictException()`
`16`	`14`	`{`
`@@ -20,7 +18,7 @@ public CouchConflictException(string message) : base(message)`
`20`	`18`	`{`
`21`	`19`	`}`
`22`	`20`
`23`		`- public CouchConflictException(string message, System.Exception innerException) : base(message, innerException)`
	`21`	`+ public CouchConflictException(string message, Exception innerException) : base(message, innerException)`
`24`	`22`	`{`
`25`	`23`	`}`
`26`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System;`
	`1`	`+using CouchDB.Driver.DTOs;`
	`2`	`+using System;`
`2`	`3`
`3`	`4`	`namespace CouchDB.Driver.Exceptions`
`4`	`5`	`{`
`@@ -12,18 +13,31 @@ public class CouchException : Exception`
`12`	`13`	`/// </summary>`
`13`	`14`	`/// <param name="message">Error message</param>`
`14`	`15`	`/// <param name="reason">Error reason</param>`
`15`		`- public CouchException(string message, string reason) : base(message, new Exception(reason)) { }`
	`16`	`+ public CouchException(string message, string reason) : this(message, reason, null)`
	`17`	`+ {`
	`18`	`+ }`
	`19`	`+`
	`20`	`+ public CouchException() : this(null, null, null)`
	`21`	`+ {`
	`22`	`+ }`
`16`	`23`
`17`		`- public CouchException()`
	`24`	`+ public CouchException(string message) : this(message, null, null)`
`18`	`25`	`{`
`19`	`26`	`}`
`20`	`27`
`21`		`- public CouchException(string message) : base(message)`
	`28`	`+ public CouchException(string message, Exception innerException) : this(message, null, innerException)`
`22`	`29`	`{`
`23`	`30`	`}`
`24`	`31`
`25`		`- public CouchException(string message, Exception innerException) : base(message, innerException)`
	`32`	`+ internal CouchException(CouchError couchError, Exception innerException) : this(couchError?.Error, couchError?.Reason, innerException)`
`26`	`33`	`{`
`27`	`34`	`}`
	`35`	`+`
	`36`	`+ public CouchException(string message, string reason, Exception innerException) : base(message, innerException)`
	`37`	`+ {`
	`38`	`+ Reason = reason;`
	`39`	`+ }`
	`40`	`+`
	`41`	`+ public string Reason { get; }`
`28`	`42`	`}`
`29`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,41 +23,25 @@ public static async Task<T> SendRequestAsync<T>(this Task<T> asyncRequest)`
`23`	`23`	`}`
`24`	`24`	`catch (FlurlHttpException ex)`
`25`	`25`	`{`
`26`		`- CouchError couchError;`
`27`		`- try`
`28`		`- {`
`29`		`- couchError = await ex.GetResponseJsonAsync<CouchError>().ConfigureAwait(false);`
`30`		`- }`
`31`		`- catch`
	`26`	`+ CouchError couchError = await ex.GetResponseJsonAsync<CouchError>().ConfigureAwait(false);`
	`27`	`+`
	`28`	`+ if (couchError == null)`
`32`	`29`	`{`
`33`		`- throw;`
	`30`	`+ couchError = new CouchError();`
`34`	`31`	`}`
`35`	`32`
`36`		`- if (couchError != null)`
	`33`	`+ switch (ex.Call.HttpStatus)`
`37`	`34`	`{`
`38`		`- switch (ex.Call.HttpStatus)`
`39`		`- {`
`40`		`- case HttpStatusCode.Conflict:`
`41`		`- throw couchError.NewCouchExteption(typeof(CouchConflictException));`
`42`		`- case HttpStatusCode.NotFound:`
`43`		`- throw couchError.NewCouchExteption(typeof(CouchNotFoundException));`
`44`		`- case HttpStatusCode.BadRequest:`
`45`		`- if (couchError.Error == "no_usable_index")`
`46`		`- {`
`47`		`- throw couchError.NewCouchExteption(typeof(CouchNoIndexException));`
`48`		`- }`
`49`		`- break;`
`50`		`- }`
	`35`	`+ case HttpStatusCode.Conflict:`
	`36`	`+ throw new CouchConflictException(couchError, ex);`
	`37`	`+ case HttpStatusCode.NotFound:`
	`38`	`+ throw new CouchNotFoundException(couchError, ex);`
	`39`	`+ case HttpStatusCode.BadRequest when couchError.Error == "no_usable_index":`
	`40`	`+ throw new CouchNoIndexException(couchError, ex);`
	`41`	`+ default:`
	`42`	`+ throw new CouchException(couchError, ex);`
`51`	`43`	`}`
`52`		`- throw new CouchException(couchError.Error, couchError.Reason);`
`53`	`44`	`}`
`54`	`45`	`}`
`55`		`-`
`56`		`- private static Exception NewCouchExteption(this CouchError e, Type type)`
`57`		`- {`
`58`		`- ConstructorInfo ctor = type.GetConstructor(new[] { typeof(string), typeof(string) });`
`59`		`- var exception = (CouchException)ctor.Invoke(new string[] { e.Error, e.Reason });`
`60`		`- return exception;`
`61`		`- }`
`62`	`46`	`}`
`63`	`47`	`}`