added test cases using non-null operator to buildTypeWeight and weightFunction tests

Author: shalarewicz

test/analysis/buildTypeWeights.test.ts

@@ -443,6 +443,78 @@ describe('Test buildTypeWeightsFromSchema function', () => {
             });
         });
 
+        describe('Not null operator (!) is used', () => {
+            test('on a scalar, enum or object type', () => {
+                schema = buildSchema(`
+                type Human{
+                    homePlanet: String!
+                    age: Int!
+                    isHero: Boolean!
+                    droids: Droid!
+                    episode: Episode!
+                }
+                type Droid {
+                    primaryFunction: String
+                }
+                enum Episode {
+                    NEWHOPE
+                    EMPIRE
+                    JEDI
+                }
+                `);
+
+                expect(buildTypeWeightsFromSchema(schema)).toEqual({
+                    human: {
+                        weight: 1,
+                        fields: {
+                            homePlanet: 0,
+                            age: 0,
+                            isHero: 0,
+                        },
+                    },
+                    droid: {
+                        weight: 1,
+                        fields: {
+                            primaryFunction: 0,
+                        },
+                    },
+                });
+            });
+
+            test('on list types', () => {
+                schema = buildSchema(`
+                type Planet{
+                    droids(first: Int!): [Droid]!
+                    heroDroids(first: Int!): [Droid!]
+                    villainDroids(first: Int!):[Droid!]!
+                }
+                type Droid {
+                    primaryFunction: String
+                }`);
+
+                expect(buildTypeWeightsFromSchema(schema)).toEqual({
+                    planet: {
+                        weight: 1,
+                        fields: {
+                            droids: expect.any(Function),
+                            heroDroids: expect.any(Function),
+                            villainDroids: expect.any(Function),
+                        },
+                    },
+                    droid: {
+                        weight: 1,
+                        fields: {
+                            primaryFunction: 0,
+                        },
+                    },
+                    episode: {
+                        weight: 0,
+                        fields: {},
+                    },
+                });
+            });
+        });
+
         // TODO: Tests should be written to account for the additional scenarios possible in a schema
         // Mutation type
         // Input types (a part of mutations?)

test/analysis/weightFunction.test.ts

@@ -18,8 +18,10 @@ describe('Weight Function correctly parses Argument Nodes if', () => {
         type Query {
             reviews(episode: Episode!, first: Int = 5): [Review]
             heroes(episode: Episode!, first: Int): [Review]
-            villains(episode: Episode!, limit: Int! = 3): [Review] 
-            characters(episode: Episode!, limit: Int!): [Review] 
+            villains(episode: Episode!, limit: Int! = 3): [Review]! 
+            characters(episode: Episode!, limit: Int!): [Review!]
+            droids(episode: Episode!, limit: Int!): [Review!]!
+            
         }
         type Review {
             episode: Episode
@@ -78,6 +80,20 @@ describe('Weight Function correctly parses Argument Nodes if', () => {
         });
     });
 
+    test('the list is defined with non-null operators (!)', () => {
+        const villainsQuery = `query { villains(episode: NEWHOPE, limit: 3) { stars, episode } }`;
+        const willainsQueryAST: DocumentNode = parse(villainsQuery);
+        expect(getQueryTypeComplexity(willainsQueryAST, {}, typeWeights)).toBe(4);
+
+        const charQuery = `query { characters(episode: NEWHOPE, limit: 3) { stars, episode } }`;
+        const charQueryAST: DocumentNode = parse(charQuery);
+        expect(getQueryTypeComplexity(charQueryAST, {}, typeWeights)).toBe(4);
+
+        const droidsQuery = `droidsQuery { droids(episode: NEWHOPE, limit: 3) { stars, episode } }`;
+        const droidsQueryAST: DocumentNode = parse(droidsQuery);
+        expect(getQueryTypeComplexity(droidsQueryAST, {}, typeWeights)).toBe(4);
+    });
+
     test('a custom object weight was configured', () => {
         const customTypeWeights: TypeWeightObject = buildTypeWeightsFromSchema(schema, {
             object: 3,