updated typeComplexity tests to better account for GraphQL variables.

Identified bugs when parsing fieldNodes and building typeWeight objects

Author: shalarewicz

src/@types/buildTypeWeights.d.ts

@@ -17,3 +17,7 @@ export interface TypeWeightConfig {
     scalar?: number;
     connection?: number;
 }
+
+type Variables = {
+    [index: string]: readonly unknown;
+};

src/analysis/ASTnodefunctions.ts

@@ -8,7 +8,7 @@ import {
     SelectionNode,
     ArgumentNode,
 } from 'graphql';
-import { FieldWeight, TypeWeightObject } from '../@types/buildTypeWeights';
+import { FieldWeight, TypeWeightObject, Variables } from '../@types/buildTypeWeights';
 
 // TODO: handle variables and arguments
 // ! this is not functional
@@ -48,7 +48,7 @@ const getArgObj = (args: ArgumentNode[]): { [index: string]: any } => {
 export function fieldNode(
     node: FieldNode,
     typeWeights: TypeWeightObject,
-    variables: any | undefined,
+    variables: Variables,
     parentName: string
 ): number {
     let complexity = 0;
@@ -73,6 +73,8 @@ export function fieldNode(
             // if the feild weight is a number, add the number to the total complexity
             complexity += fieldWeight;
         } else if (node.arguments) {
+            // BUG: This code is reached when fieldWeight is undefined, which could result from an invalid query or this type
+            // missing from the typeWeight object. If left unhandled an error is thrown
             // otherwise the the feild weight is a list, invoke the function with variables
             // TODO: calculate the complexity for lists with arguments and varibales
             // ! this is not functional
@@ -86,7 +88,7 @@ export function fieldNode(
 export function selectionNode(
     node: SelectionNode,
     typeWeights: TypeWeightObject,
-    variables: any | undefined,
+    variables: Variables,
     parentName: string
 ): number {
     let complexity = 0;
@@ -103,7 +105,7 @@ export function selectionNode(
 export function selectionSetNode(
     node: SelectionSetNode,
     typeWeights: TypeWeightObject,
-    variables: any | undefined,
+    variables: Variables,
     parentName: string
 ): number {
     let complexity = 0;
@@ -119,7 +121,7 @@ export function selectionSetNode(
 export function definitionNode(
     node: DefinitionNode,
     typeWeights: TypeWeightObject,
-    variables: any | undefined
+    variables: Variables
 ): number {
     let complexity = 0;
     // check the kind property against the set of definiton nodes that are possible
@@ -145,7 +147,7 @@ export function definitionNode(
 export function documentNode(
     node: DocumentNode,
     typeWeights: TypeWeightObject,
-    variables: any | undefined
+    variables: Variables
 ): number {
     let complexity = 0;
     // iterate through 'definitions' array on the document node

src/analysis/buildTypeWeights.ts

@@ -83,6 +83,7 @@ function parseQuery(
             // If query has an argument matching one of the limiting keywords and resolves to a list then the weight of the query
             // should be dependent on both the weight of the resolved type and the limiting argument.
             // FIXME: Can nonnull wrap list types?
+            // BUG: Lists need to be accounted for in all types not just queries
             if (KEYWORDS.includes(arg.name) && isListType(resolveType)) {
                 // Get the type that comprises the list
                 const listType = resolveType.ofType;

src/analysis/typeComplexityAnalysis.ts

@@ -1,5 +1,5 @@
 import { DocumentNode } from 'graphql';
-import { TypeWeightObject } from '../@types/buildTypeWeights';
+import { TypeWeightObject, Variables } from '../@types/buildTypeWeights';
 import { documentNode } from './ASTnodefunctions';
 
 /**
@@ -9,12 +9,12 @@ import { documentNode } from './ASTnodefunctions';
  * TO DO: extend the functionality to work for mutations and subscriptions and directives
  *
  * @param {string} queryAST
- * @param {any | undefined} varibales
+ * @param {Variables} variables
  * @param {TypeWeightObject} typeWeights
  */
 function getQueryTypeComplexity(
     queryAST: DocumentNode,
-    variables: any | undefined,
+    variables: Variables,
     typeWeights: TypeWeightObject
 ): number {
     let complexity = 0;

test/analysis/typeComplexityAnalysis.test.ts

@@ -1,7 +1,6 @@
-import { ArgumentNode } from 'graphql/language';
 import { parse } from 'graphql';
 import getQueryTypeComplexity from '../../src/analysis/typeComplexityAnalysis';
-import { TypeWeightObject } from '../../src/@types/buildTypeWeights';
+import { TypeWeightObject, Variables } from '../../src/@types/buildTypeWeights';
 
 /** 
  * Here is the schema that creates the followning 'typeWeightsObject' used for the tests
@@ -97,15 +96,23 @@ import { TypeWeightObject } from '../../src/@types/buildTypeWeights';
     to character, human and droid
 */
 
+const mockWeightFunction = jest.fn();
+const mockHumanFriendsFunction = jest.fn();
+const mockDroidFriendsFunction = jest.fn();
+
 // this object is created by the schema above for use in all the tests below
 const typeWeights: TypeWeightObject = {
     query: {
         // object type
         weight: 1,
         fields: {
-            // FIXME: update the function def that is supposed te be here to match implementation
-            // FIXME: add the function definition for the 'search' field which returns a list
-            reviews: (args: ArgumentNode[]): number => 10,
+            reviews: mockWeightFunction,
+            hero: 1,
+            search: jest.fn(), // FIXME: Unbounded list result
+            character: 1,
+            droid: 1,
+            human: 1,
+            scalars: 1,
         },
     },
     episode: {
@@ -129,6 +136,8 @@ const typeWeights: TypeWeightObject = {
             id: 0,
             name: 0,
             homePlanet: 0,
+            appearsIn: jest.fn(), // FIXME: resolves to an unbounded list of enums. We aren't handling this yet
+            friends: mockHumanFriendsFunction,
         },
     },
     droid: {
@@ -137,6 +146,8 @@ const typeWeights: TypeWeightObject = {
         fields: {
             id: 0,
             name: 0,
+            appearsIn: jest.fn(), // FIXME: resolves to an unbounded list of enums. We aren't handling this yet
+            friends: mockDroidFriendsFunction,
         },
     },
     review: {
@@ -170,8 +181,13 @@ const typeWeights: TypeWeightObject = {
 };
 
 describe('Test getQueryTypeComplexity function', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
     let query = '';
-    let variables: any | undefined;
+    let variables: Variables = {};
+
     describe('Calculates the correct type complexity for queries', () => {
         test('with one feild', () => {
             query = `query { scalars { num } }`;
@@ -203,14 +219,14 @@ describe('Test getQueryTypeComplexity function', () => {
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(2); // Query 1 + scalar 1
         });
 
-        xtest('with arguments and variables', () => {
+        test('with arguments and variables', () => {
             query = `query { hero(episode: EMPIRE) { id, name } }`;
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(2); // Query 1 + hero/character 1
-            query = `query { human(id: 1) { id, name, appearsIn } }`;
-            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(3); // Query 1 + human/character 1 + appearsIn/episode
+            query = `query { human(id: 1) { id, name, homePlanet } }`;
+            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(2); // Query 1 + human/character 1
             // argument passed in as a variable
             variables = { ep: 'EMPIRE' };
-            query = `query varibaleQuery ($ep: Episode){ hero(episode: $ep) { id, name } }`;
+            query = `query variableQuery ($ep: Episode){ hero(episode: $ep) { id, name } }`;
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(2); // Query 1 + hero/character 1
         });
 
@@ -263,15 +279,22 @@ describe('Test getQueryTypeComplexity function', () => {
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(false); // ?
         });
 
-        xtest('with lists detrmined by arguments and variables', () => {
-            query = `Query {reviews(episode: EMPIRE, first: 3) { stars, commentary } }`;
-            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(4); // 1 Query + 3 reviews
-            variables = { first: 3 };
-            query = `Query queryVaribales($first: Int) {reviews(episode: EMPIRE, first: $first) { stars, commentary } }`;
-            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(4); // 1 Query + 3 reviews
+        test('with lists determined by arguments and variables', () => {
+            query = `query {reviews(episode: EMPIRE, first: 3) { stars, commentary } }`;
+            mockWeightFunction.mockReturnValueOnce(3);
+            expect(getQueryTypeComplexity(parse(query), {}, typeWeights)).toBe(4); // 1 Query + 3 reviews
+            expect(mockWeightFunction.mock.calls.length).toBe(1);
+            expect(mockWeightFunction.mock.calls[0].length).toBe(1);
+
+            variables = { first: 4 };
+            mockWeightFunction.mockReturnValueOnce(4);
+            query = `query queryVariables($first: Int) {reviews(episode: EMPIRE, first: $first) { stars, commentary } }`;
+            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(5); // 1 Query + 3 reviews
+            expect(mockWeightFunction.mock.calls.length).toBe(2);
+            expect(mockWeightFunction.mock.calls[1].length).toBe(1);
         });
 
-        xtest('with nested lists', () => {
+        test('with nested lists', () => {
             query = `
             query { 
                 human(id: 1) { 
@@ -284,7 +307,9 @@ describe('Test getQueryTypeComplexity function', () => {
                     } 
                 }
             }`;
+            mockHumanFriendsFunction.mockReturnValueOnce(5).mockReturnValueOnce(3);
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(17); // 1 Query + 1 human/character +  (5 friends/character X 3 friends/characters)
+            expect(mockHumanFriendsFunction.mock.calls.length).toBe(2);
         });
 
         xtest('accounting for __typename feild', () => {