wrote tests for buildTypeWeights functionality and configurability

Author: evanmcneely

src/analysis/buildTypeWeights.ts

@@ -1,26 +1,5 @@
 import { GraphQLSchema } from 'graphql/type/schema';
 
-interface Fields {
-    [index: string]: number;
-}
-
-interface Type {
-    weight: number;
-    feilds: Fields;
-}
-
-interface TypeWeightObject {
-    [index: string]: Type;
-}
-
-interface TypeWeightConfig {
-    mutation?: number;
-    query?: number;
-    object?: number;
-    scalar?: number;
-    connection?: number;
-}
-
 /**
  * The default type weights object is based off of Shopifys implewentation of query
  * cost analysis. Our function should input a users configuration of type weights or fall

test/analysis/buildTypeWeights.test.ts

@@ -3,20 +3,167 @@ import { GraphQLSchema } from 'graphql/type/schema';
 import buildTypeWeightsFromSchema from '../../src/analysis/buildTypeWeights';
 
 describe('Test buildTypeWeightsFromSchema function', () => {
-    beforeEach(() => {
-        let schema: GraphQLSchema;
+    let schema: GraphQLSchema;
+
+    describe('creates the type weight object from graphql schema object with...', () => {
+        test('a single query type', () => {
+            schema = buildSchema(`
+                Query {
+                    name: String
+                    email: String
+                }`);
+
+            const typeWeightObject = buildTypeWeightsFromSchema(schema);
+
+            expect(typeWeightObject).toEqual({
+                Query: {
+                    weight: 1,
+                    fields: {
+                        name: 0,
+                        email: 0,
+                    },
+                },
+            });
+        });
+
+        test('multiple types', () => {
+            schema = buildSchema(`
+                User {
+                    name: String
+                    email: String
+                }
+
+                Movie {
+                    name: String
+                    director: String
+                }`);
+
+            const typeWeightObject = buildTypeWeightsFromSchema(schema);
+
+            expect(typeWeightObject).toEqual({
+                User: {
+                    weight: 1,
+                    fields: {
+                        name: 0,
+                        email: 0,
+                    },
+                },
+                Movie: {
+                    weight: 1,
+                    fields: {
+                        name: 0,
+                        director: 0,
+                    },
+                },
+            });
+        });
+
+        test('nested object types', () => {
+            schema = buildSchema(`
+                Query {
+                    User {
+                        name: String
+                        email: String
+                    }
+
+                    Movie {
+                        name: String
+                        director: User
+                    }  
+                }`);
+
+            const typeWeightObject = buildTypeWeightsFromSchema(schema);
+
+            expect(typeWeightObject).toEqual({
+                Query: {
+                    weight: 1,
+                    fields: {
+                        User: 1,
+                        Movie: 1,
+                    },
+                },
+                User: {
+                    weight: 1,
+                    fields: {
+                        name: 0,
+                        email: 0,
+                    },
+                },
+                Movie: {
+                    weight: 1,
+                    fields: {
+                        name: 0,
+                        director: 1,
+                    },
+                },
+            });
+        });
     });
 
-    describe('query types', () => {
-        // cretes type weight object from schema with multipl types
-        test('creates the type weight object from graphql schema object', () => {});
+    describe('changes type weight object with user configuration of query of...', () => {
+        let expectedOutput: TypeWeightObject;
+
+        beforeEach(() => {
+            schema = buildSchema(`
+                Query {
+                    User {
+                        name: String
+                        email: String
+                    }
+
+                    Movie {
+                        name: String
+                        director: User
+                    }  
+                }`);
+
+            expectedOutput = {
+                Query: {
+                    weight: 1,
+                    fields: {
+                        User: 1,
+                        Movie: 1,
+                    },
+                },
+                User: {
+                    weight: 1,
+                    fields: {
+                        name: 0,
+                        email: 0,
+                    },
+                },
+                Movie: {
+                    weight: 1,
+                    fields: {
+                        name: 0,
+                        director: 1,
+                    },
+                },
+            };
+        });
+
+        test('query parameter', () => {
+            const typeWeightObject = buildTypeWeightsFromSchema(schema, {
+                query: 2,
+            });
+            expectedOutput.query.weight = 2;
+
+            expect(typeWeightObject).toEqual({ expectedOutput });
+        });
+
+        test('all objects types', () => {
+            const typeWeightObject = buildTypeWeightsFromSchema(schema, {
+                object: 2,
+            });
+            expectedOutput.query.fields.user = 2;
+            expectedOutput.query.fields.movie = 2;
+            expectedOutput.user.weight = 2;
+            expectedOutput.movie.weight = 2;
+            expectedOutput.movie.fields.director = 2;
 
-        // creates tyep weight object from schema with nested types
-        test('');
+            expect(typeWeightObject).toEqual({ expectedOutput });
+        });
     });
 
-    /**
-     * Above tests are for query types only
-     * todo testing functionality for mutations, pagination, lists, etc. is not yet implemented
-     */
+    describe('throws an error on...', () => {});
 });