added a test for fragments with multiple levels of nesting and unions with non-null types

Author: evanmcneely

test/analysis/buildTypeWeights.test.ts

@@ -509,12 +509,6 @@ describe('Test buildTypeWeightsFromSchema function', () => {
                     },
                 });
             });
-
-            xtest('additional test cases for ...', () => {
-                // TODO: unions with non-null types
-                // unions with lists of non-null types
-                // lists with > 2 levels of nesting (may need to add these for lists on other types as well)
-            });
         });
 
         xdescribe('Not null operator (!) is used', () => {
@@ -612,6 +606,55 @@ describe('Test buildTypeWeightsFromSchema function', () => {
                     },
                 });
             });
+
+            test('on union types', () => {
+                schema = buildSchema(`
+                union SearchResult = Human | Droid
+                type Human{
+                    name: String
+                    homePlanet: String
+                    search(first: Int!): [SearchResult!]!
+                }
+                type Droid {
+                    name: String
+                    primaryFunction: String!
+                    search(first: Int!): [SearchResult!]!
+                }`);
+                expect(buildTypeWeightsFromSchema(schema)).toEqual({
+                    searchresult: {
+                        weight: 1,
+                        fields: {
+                            name: { weight: 0 },
+                            search: {
+                                resolveTo: 'searchresult',
+                                weight: expect.any(Function),
+                            },
+                        },
+                    },
+                    human: {
+                        weight: 1,
+                        fields: {
+                            name: { weight: 0 },
+                            homePlanet: { weight: 0 },
+                            search: {
+                                resolveTo: 'searchresult',
+                                weight: expect.any(Function),
+                            },
+                        },
+                    },
+                    droid: {
+                        weight: 1,
+                        fields: {
+                            name: { weight: 0 },
+                            primaryFunction: { weight: 0 },
+                            search: {
+                                resolveTo: 'searchresult',
+                                weight: expect.any(Function),
+                            },
+                        },
+                    },
+                });
+            });
         });
 
         // TODO: Tests should be written to account for the additional scenarios possible in a schema

test/analysis/typeComplexityAnalysis.test.ts

@@ -600,6 +600,40 @@ describe('Test getQueryTypeComplexity function', () => {
                     expect(getQueryTypeComplexity(parse(query), {}, unionTypeWeights)).toBe(5);
                 });
 
+                test('that have greater than 2  levels of nesting', () => {
+                    query = `
+                    query {
+                        hero(episode: EMPIRE) {
+                            name
+                            ... on Droid {
+                                primaryFunction
+                                friends(first: 5) {
+                                    name
+                                    friends(first: 3) {
+                                        name
+                                    }
+                                }
+                            }
+                            ... on Human {
+                                homePlanet
+                                friends(first: 5) {
+                                    name
+                                    friends(first: 3) {
+                                        name
+                                    }
+                                }
+                            }
+                        }
+                    }`;
+                    mockCharacterFriendsFunction.mockReturnValue(3);
+                    mockDroidFriendsFunction.mockReturnValueOnce(20);
+                    mockHumanFriendsFunction.mockReturnValueOnce(20);
+                    // Query 1 + 1 hero + 3 friends/character
+                    expect(getQueryTypeComplexity(parse(query), variables, unionTypeWeights)).toBe(
+                        22
+                    );
+                });
+
                 xtest('that include a directive', () => {
                     query = `
                         query {