Add missing tests for GraphQLFileLoader, JsonFileLoader and ModuleLoader (#1797)

Author: danielrearden

packages/loaders/git/tests/loader.spec.ts

@@ -24,15 +24,15 @@ describe('GitLoader', () => {
       sync: loader.canLoadSync.bind(loader),
     })(canLoad => {
       it('should return true for a valid pointer', async () => {
-        expect(canLoad(getPointer('some-file.graphql'))).resolves.toBe(true);
+        await expect(canLoad(getPointer('some-file.graphql'))).resolves.toBe(true);
       });
 
       it('should return false if pointer does not begin with "git:"', async () => {
-        expect(canLoad(getPointer('some-file.graphql').substring(4))).resolves.toBe(false);
+        await expect(canLoad(getPointer('some-file.graphql').substring(4))).resolves.toBe(false);
       });
 
       it('should return false if pointer is not a string', async () => {
-        expect(canLoad(42 as any)).resolves.toBe(false);
+        await expect(canLoad(42 as any)).resolves.toBe(false);
       });
     });
   });

packages/loaders/graphql-file/src/index.ts

@@ -63,7 +63,7 @@ export class GraphQLFileLoader implements UniversalLoader<GraphQLFileLoaderOptio
   ): Promise<boolean> {
     if (isValidPath(pointer)) {
       if (FILE_EXTENSIONS.find(extension => pointer.endsWith(extension))) {
-        const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd, pointer);
+        const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd || processCwd(), pointer);
         return pathExists(normalizedFilePath);
       }
     }
@@ -74,7 +74,7 @@ export class GraphQLFileLoader implements UniversalLoader<GraphQLFileLoaderOptio
   canLoadSync(pointer: SchemaPointerSingle | DocumentPointerSingle, options: GraphQLFileLoaderOptions): boolean {
     if (isValidPath(pointer)) {
       if (FILE_EXTENSIONS.find(extension => pointer.endsWith(extension))) {
-        const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd, pointer);
+        const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd || processCwd(), pointer);
         return pathExistsSync(normalizedFilePath);
       }
     }
@@ -83,15 +83,14 @@ export class GraphQLFileLoader implements UniversalLoader<GraphQLFileLoaderOptio
   }
 
   async load(pointer: SchemaPointerSingle | DocumentPointerSingle, options: GraphQLFileLoaderOptions): Promise<Source> {
-    const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd, pointer);
+    const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd || processCwd(), pointer);
     const rawSDL: string = await readFile(normalizedFilePath, { encoding: 'utf8' });
 
     return this.handleFileContent(rawSDL, pointer, options);
   }
 
   loadSync(pointer: SchemaPointerSingle | DocumentPointerSingle, options: GraphQLFileLoaderOptions): Source {
-    const cwd = options.cwd || processCwd();
-    const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(cwd, pointer);
+    const normalizedFilePath = isAbsolute(pointer) ? pointer : resolve(options.cwd || processCwd(), pointer);
     const rawSDL = readFileSync(normalizedFilePath, { encoding: 'utf8' });
     return this.handleFileContent(rawSDL, pointer, options);
   }

packages/loaders/graphql-file/tests/loader.spec.ts

@@ -0,0 +1,68 @@
+import { join } from 'path';
+
+import { Source } from '@graphql-tools/utils';
+
+import { GraphQLFileLoader } from '../src';
+import { runTests } from '../../../testing/utils';
+
+describe('GraphQLFileLoader', () => {
+  const loader = new GraphQLFileLoader();
+  const getPointer = (fileName: string) => {
+    return join('packages/loaders/graphql-file/tests/test-files', fileName);
+  };
+
+  describe('loaderId', () => {
+    it('should return a loader id', () => {
+      expect(loader.loaderId()).toBeDefined();
+    });
+  });
+
+  describe('canLoad', () => {
+    runTests({
+      async: loader.canLoad.bind(loader),
+      sync: loader.canLoadSync.bind(loader),
+    })(canLoad => {
+      it('should return true for a valid pointer', async () => {
+        await expect(canLoad(getPointer('type-defs.graphql'), {})).resolves.toBe(true);
+      });
+
+      it('should return true for a valid absolute path', async () => {
+        await expect(canLoad(join(process.cwd(), getPointer('type-defs.graphql')), {})).resolves.toBe(true);
+      });
+
+      it('should return false if pointer is not a valid path', async () => {
+        await expect(canLoad(getPointer('!bad-path.graphql'), {})).resolves.toBe(false);
+      });
+
+      it('should return false if pointer does not end with correct file extension', async () => {
+        await expect(canLoad(getPointer('bad-ext.garphql'), {})).resolves.toBe(false);
+      });
+
+      it('should return false if pointer is for non-existent file', async () => {
+        await expect(canLoad(getPointer('bad-file.graphql'), {})).resolves.toBe(false);
+      });
+    });
+  });
+
+  describe('load', () => {
+    runTests({
+      async: loader.load.bind(loader),
+      sync: loader.loadSync.bind(loader),
+    })(load => {
+      it('should load type definitions from a .graphql file', async () => {
+        const result: Source = await load(getPointer('type-defs.graphql'), {});
+        expect(result.document).toBeDefined();
+      });
+
+      it('should load file from absolute path', async () => {
+        const result: Source = await load(join(process.cwd(), getPointer('type-defs.graphql')), {});
+        expect(result.document).toBeDefined();
+      });
+
+      it('should load file with #import expression', async () => {
+        const result: Source = await load(getPointer('type-defs-with-import.graphql'), {});
+        expect(result.document?.definitions.length).toBe(2);
+      });
+    });
+  });
+});

packages/loaders/graphql-file/tests/test-files/import-me.graphql

@@ -0,0 +1,3 @@
+type Mutation {
+  sayGoodbye: String
+}

packages/loaders/graphql-file/tests/test-files/type-defs-with-import.graphql

@@ -0,0 +1,5 @@
+#import Mutation from "./import-me.graphql"
+
+type Query {
+  hello: String
+}

packages/loaders/graphql-file/tests/test-files/type-defs.graphql

@@ -0,0 +1,3 @@
+type Query {
+  hello: String
+}

packages/loaders/json-file/src/index.ts

@@ -75,7 +75,7 @@ export class JsonFileLoader implements DocumentLoader {
       const jsonContent: string = await readFile(normalizedFilePath, { encoding: 'utf8' });
       return parseGraphQLJSON(pointer, jsonContent, options);
     } catch (e) {
-      throw new Error(`Unable to read JSON file: ${normalizedFilePath}: ${e.message || e}`);
+      throw new Error(`Unable to read JSON file: ${normalizedFilePath}: ${e.message || /* istanbul ignore next */ e}`);
     }
   }
 
@@ -86,7 +86,7 @@ export class JsonFileLoader implements DocumentLoader {
       const jsonContent = readFileSync(normalizedFilepath, 'utf8');
       return parseGraphQLJSON(pointer, jsonContent, options);
     } catch (e) {
-      throw new Error(`Unable to read JSON file: ${normalizedFilepath}: ${e.message || e}`);
+      throw new Error(`Unable to read JSON file: ${normalizedFilepath}: ${e.message || /* istanbul ignore next */ e}`);
     }
   }
 }

packages/loaders/json-file/tests/loader.spec.ts

@@ -0,0 +1,72 @@
+import { join } from 'path';
+
+import { Source } from '@graphql-tools/utils';
+
+import { JsonFileLoader } from '../src';
+import { runTests } from '../../../testing/utils';
+
+describe('JsonFileLoader', () => {
+  const loader = new JsonFileLoader();
+  const getPointer = (fileName: string) => {
+    return join('packages/loaders/json-file/tests/test-files', fileName);
+  };
+
+  describe('loaderId', () => {
+    it('should return a loader id', () => {
+      expect(loader.loaderId()).toBeDefined();
+    });
+  });
+
+  describe('canLoad', () => {
+    runTests({
+      async: loader.canLoad.bind(loader),
+      sync: loader.canLoadSync.bind(loader),
+    })(canLoad => {
+      it('should return true for a valid pointer', async () => {
+        await expect(canLoad(getPointer('introspection.json'), {})).resolves.toBe(true);
+      });
+
+      it('should return true for a valid absolute path', async () => {
+        await expect(canLoad(join(process.cwd(), getPointer('introspection.json')), {})).resolves.toBe(true);
+      });
+
+      it('should return false if pointer is not a valid path', async () => {
+        await expect(canLoad(getPointer('!bad-path.json'), {})).resolves.toBe(false);
+      });
+
+      it('should return false if pointer does not end with correct file extension', async () => {
+        await expect(canLoad(getPointer('bad-ext.json5'), {})).resolves.toBe(false);
+      });
+
+      it('should return false if pointer is for non-existent file', async () => {
+        await expect(canLoad(getPointer('bad-file.json'), {})).resolves.toBe(false);
+      });
+    });
+  });
+
+  describe('load', () => {
+    runTests({
+      async: loader.load.bind(loader),
+      sync: loader.loadSync.bind(loader),
+    })(load => {
+      it('should load introspection data from a .json file', async () => {
+        const result: Source = await load(getPointer('introspection.json'), {});
+        expect(result.schema).toBeDefined();
+      });
+
+      it('should load type definitions from a .json file', async () => {
+        const result: Source = await load(getPointer('type-defs.json'), {});
+        expect(result.document).toBeDefined();
+      });
+
+      it('should load file from absolute path', async () => {
+        const result: Source = await load(join(process.cwd(), getPointer('type-defs.json')), {});
+        expect(result.document).toBeDefined();
+      });
+
+      it('should throw when the file content is malformed', async () => {
+        await expect(load(getPointer('malformed.json'), {})).rejects.toThrowError('Unable to read JSON file');
+      });
+    });
+  });
+});