added tests for mutations and started looking at tests for connections

Author: evanmcneely

test/analysis/buildTypeWeights.test.ts

@@ -314,8 +314,8 @@ describe('Test buildTypeWeightsFromSchema function', () => {
             type Character {
                 id: ID!
                 name: String!
-                friends(first:Int after: String): [Character]
-                friendsConnection (first: Int): FriendsConnection
+                friends(first: Int): [Character]
+                friendsConnection(first: Int, after: ID): FriendsConnection!
             }
             type FriendsConnection {
                 totalCount: Int
@@ -345,7 +345,8 @@ describe('Test buildTypeWeightsFromSchema function', () => {
                     fields: {
                         id: { weight: 0 },
                         name: { weight: 0 },
-                        friends: { resolveTo: 'friendsConnection' },
+                        friends: { resolveTo: 'character', weight: expect.any(Function) },
+                        friendsConnection: { resolveTo: 'friendsConnection' },
                     },
                 },
                 friendsConnection: {

test/analysis/typeComplexityAnalysis.test.ts

@@ -78,6 +78,8 @@ import { TypeWeightObject, Variables } from '../../src/@types/buildTypeWeights';
         stars: Int!
         commentary: String
     }
+    
+
 
  *   
  * TODO: extend this schema to include mutations, subscriptions and pagination
@@ -86,7 +88,8 @@ import { TypeWeightObject, Variables } from '../../src/@types/buildTypeWeights';
     type Subscription {
         reviewAdded(episode: Episode): Review
     }
-    type FriendsConnection {
+
+        type FriendsConnection {
         totalCount: Int
         edges: [FriendsEdge]
         friends: [Character]
@@ -918,6 +921,9 @@ describe('Test getQueryTypeComplexity function', () => {
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(5); // 1 Query + 4 search results
         });
 
+        // TODO: create tests for an implementation of the connection pagination convention -- need soln for unbounded lists
+        xdescribe('connection pagination convention', () => {});
+
         // TODO: directives @skip, @include and custom directives
     });
 
@@ -933,6 +939,32 @@ describe('Test getQueryTypeComplexity function', () => {
             }`;
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(11); // Mutation 10 + review 1
         });
+
+        test('mutation with no feilds queried', () => {
+            variables = { review: { stars: 5, commentary: 'good' } };
+            query = `mutation createReviewMutation($review: ReviewInput!) { 
+                createReview(episode: Empire, review: $review) 
+            }`;
+            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(11); // Mutation 10 + review 1
+        });
+
+        test('mutation and query definitons', () => {
+            variables = { review: { stars: 5, commentary: 'good' } };
+            query = `mutation createReviewMutation($review: ReviewInput!) { 
+                createReview(episode: Empire, review: $review) {
+                    stars
+                    commentary
+                    episode
+                }
+            }
+            
+            query {
+                hero(episode: EMPIRE) {
+                    name
+                }
+            }`;
+            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(13); // Mutation 10 + review 1 + query 1 + character 1
+        });
     });
 
     xdescribe('Calculates the correct type complexity for subscriptions', () => {});