test(queryParser): add test coverage and handle exception

Author: jaredcnance

src/JsonApiDotNetCore/Services/QueryParser.cs

@@ -112,38 +112,47 @@ protected virtual(string operation, string value) ParseFilterOperation(string va
             return (prefix, value);
         }
 
-        protected virtual PageQuery ParsePageQuery(PageQuery pageQuery, string key, string value) {
+        protected virtual PageQuery ParsePageQuery(PageQuery pageQuery, string key, string value)
+        {
             // expected input = page[size]=10
             //                  page[number]=1
             pageQuery = pageQuery ?? new PageQuery();
 
-            var propertyName = key.Split(OPEN_BRACKET, CLOSE_BRACKET) [1];
+            var propertyName = key.Split(OPEN_BRACKET, CLOSE_BRACKET)[1];
 
             const string SIZE = "size";
             const string NUMBER = "number";
 
             if (propertyName == SIZE)
-                pageQuery.PageSize = Convert.ToInt32(value);
+                pageQuery.PageSize = int.TryParse(value, out var pageSize) ?
+                pageSize :
+                throw new JsonApiException(400, $"Invalid page size '{value}'");
+
             else if (propertyName == NUMBER)
-                pageQuery.PageOffset = Convert.ToInt32(value);
+                pageQuery.PageOffset = int.TryParse(value, out var pageOffset) ?
+                pageOffset :
+                throw new JsonApiException(400, $"Invalid page size '{value}'");
 
             return pageQuery;
         }
 
         // sort=id,name
         // sort=-id
-        protected virtual List<SortQuery> ParseSortParameters(string value) {
+        protected virtual List<SortQuery> ParseSortParameters(string value)
+        {
             var sortParameters = new List<SortQuery>();
 
             const char DESCENDING_SORT_OPERATOR = '-';
             var sortSegments = value.Split(COMMA);
 
-            foreach (var sortSegment in sortSegments) {
+            foreach (var sortSegment in sortSegments)
+            {
 
                 var propertyName = sortSegment;
                 var direction = SortDirection.Ascending;
 
-                if (sortSegment[0] == DESCENDING_SORT_OPERATOR) {
+                if (sortSegment[0] == DESCENDING_SORT_OPERATOR)
+                {
                     direction = SortDirection.Descending;
                     propertyName = propertyName.Substring(1);
                 }
@@ -166,37 +175,47 @@ protected virtual List<string> ParseIncludedRelationships(string value) {
                 .ToList();
         }
 
-        protected virtual List<string> ParseFieldsQuery(string key, string value) {
+        protected virtual List<string> ParseFieldsQuery(string key, string value)
+        {
             // expected: fields[TYPE]=prop1,prop2
-            var typeName = key.Split(OPEN_BRACKET, CLOSE_BRACKET) [1];
+            var typeName = key.Split(OPEN_BRACKET, CLOSE_BRACKET)[1];
 
             const string ID = "Id";
             var includedFields = new List<string> { ID };
 
-            if (typeName != _controllerContext.RequestEntity.EntityName)
+            // this will not support nested inclusions, it requires that the typeName is the current request type
+            if (string.Equals(typeName, _controllerContext.RequestEntity.EntityName, StringComparison.OrdinalIgnoreCase) == false)
                 return includedFields;
 
             var fields = value.Split(COMMA);
-            foreach (var field in fields) {
-                var internalAttrName = _controllerContext.RequestEntity
+            foreach (var field in fields)
+            {
+                var attr = _controllerContext.RequestEntity
                     .Attributes
-                    .SingleOrDefault(attr => attr.PublicAttributeName == field)
-                    .InternalAttributeName;
+                    .SingleOrDefault(a => string.Equals(a.PublicAttributeName, field, StringComparison.OrdinalIgnoreCase));
+
+                if (attr == null) throw new JsonApiException(400, $"'{_controllerContext.RequestEntity.EntityName}' does not contain '{field}'.");
+
+                var internalAttrName = attr.InternalAttributeName;
                 includedFields.Add(internalAttrName);
             }
 
             return includedFields;
         }
 
-        protected virtual AttrAttribute GetAttribute(string propertyName) {
-            try {
+        protected virtual AttrAttribute GetAttribute(string propertyName)
+        {
+            try
+            {
                 return _controllerContext
                     .RequestEntity
                     .Attributes
                     .Single(attr =>
                         string.Equals(attr.PublicAttributeName, propertyName, StringComparison.OrdinalIgnoreCase)
                     );
-            } catch (InvalidOperationException e) {
+            }
+            catch (InvalidOperationException e)
+            {
                 throw new JsonApiException(400, $"Attribute '{propertyName}' does not exist on resource '{_controllerContext.RequestEntity.EntityName}'", e);
             }
         }

test/UnitTests/Services/QueryParser_Tests.cs

@@ -224,5 +224,133 @@ public void Can_Disable_Fields()
             // assert
             Assert.Empty(querySet.Fields);
         }
+
+        [Fact]
+        public void Can_Parse_Fields_Query()
+        {
+            // arrange
+            const string type = "articles";
+            const string attrName = "some-field";
+            const string internalAttrName = "SomeField";
+
+            var query = new Dictionary<string, StringValues> { { $"fields[{type}]", new StringValues(attrName) } };
+
+            _queryCollectionMock
+                .Setup(m => m.GetEnumerator())
+                .Returns(query.GetEnumerator());
+
+            _controllerContextMock
+                .Setup(m => m.RequestEntity)
+                .Returns(new ContextEntity
+                {
+                    EntityName = type,
+                        Attributes = new List<AttrAttribute>
+                        {
+                            new AttrAttribute(attrName)
+                            {
+                                InternalAttributeName = internalAttrName
+                            }
+                        }
+                });
+
+            var queryParser = new QueryParser(_controllerContextMock.Object, new JsonApiOptions());
+
+            // act
+            var querySet = queryParser.Parse(_queryCollectionMock.Object);
+
+            // assert
+            Assert.NotEmpty(querySet.Fields);
+            Assert.Equal(2, querySet.Fields.Count);
+            Assert.Equal("Id", querySet.Fields[0]);
+            Assert.Equal(internalAttrName, querySet.Fields[1]);
+        }
+
+        [Fact]
+        public void Throws_JsonApiException_If_Field_DoesNotExist()
+        {
+            // arrange
+            const string type = "articles";
+            const string attrName = "dne";
+
+            var query = new Dictionary<string, StringValues> { { $"fields[{type}]", new StringValues(attrName) } };
+
+            _queryCollectionMock
+                .Setup(m => m.GetEnumerator())
+                .Returns(query.GetEnumerator());
+
+            _controllerContextMock
+                .Setup(m => m.RequestEntity)
+                .Returns(new ContextEntity
+                {
+                    EntityName = type,
+                        Attributes = new List<AttrAttribute>()
+                });
+
+            var queryParser = new QueryParser(_controllerContextMock.Object, new JsonApiOptions());
+
+            // act , assert
+            var ex = Assert.Throws<JsonApiException>(() => queryParser.Parse(_queryCollectionMock.Object));
+            Assert.Equal(400, ex.GetStatusCode());
+        }
+
+        [Theory]
+        [InlineData("1", 1, false)]
+        [InlineData("abcde", 0, true)]
+        [InlineData("", 0, true)]
+        public void Can_Parse_Page_Size_Query(string value, int expectedValue, bool shouldThrow)
+        {
+            // arrange
+            var query = new Dictionary<string, StringValues>
+                { { "page[size]", new StringValues(value) }
+                };
+
+            _queryCollectionMock
+                .Setup(m => m.GetEnumerator())
+                .Returns(query.GetEnumerator());
+
+            var queryParser = new QueryParser(_controllerContextMock.Object, new JsonApiOptions());
+
+            // act
+            if (shouldThrow)
+            {
+                var ex = Assert.Throws<JsonApiException>(() => queryParser.Parse(_queryCollectionMock.Object));
+                Assert.Equal(400, ex.GetStatusCode());
+            }
+            else
+            {
+                var querySet = queryParser.Parse(_queryCollectionMock.Object);
+                Assert.Equal(expectedValue, querySet.PageQuery.PageSize);
+            }
+        }
+
+        [Theory]
+        [InlineData("1", 1, false)]
+        [InlineData("abcde", 0, true)]
+        [InlineData("", 0, true)]
+        public void Can_Parse_Page_Number_Query(string value, int expectedValue, bool shouldThrow)
+        {
+            // arrange
+            var query = new Dictionary<string, StringValues>
+                { { "page[number]", new StringValues(value) }
+                };
+
+            _queryCollectionMock
+                .Setup(m => m.GetEnumerator())
+                .Returns(query.GetEnumerator());
+
+            var queryParser = new QueryParser(_controllerContextMock.Object, new JsonApiOptions());
+
+            // act
+            if (shouldThrow)
+            {
+                var ex = Assert.Throws<JsonApiException>(() => queryParser.Parse(_queryCollectionMock.Object));
+                Assert.Equal(400, ex.GetStatusCode());
+            }
+            else
+            {
+                var querySet = queryParser.Parse(_queryCollectionMock.Object);
+                Assert.Equal(expectedValue, querySet.PageQuery.PageOffset);
+            }
+        }
     }
-}
+}