feat: allow parsing multiple input types

packages/cli/src/services/check-parser/__tests__/parse-files.spec.ts

@@ -0,0 +1,305 @@
+import { Parser } from '../parser'
+import * as path from 'path'
+
+describe('project parser - getFilesAndDependencies()', () => {
+  it('should handle JS file with no dependencies', async () => {
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([path.join(__dirname, 'check-parser-fixtures', 'no-dependencies.js')])
+    expect(res.files).toHaveLength(1)
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should handle JS file with dependencies', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'simple-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.js')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.js'),
+      toAbsolutePath('dep2.js'),
+      toAbsolutePath('dep3.js'),
+      toAbsolutePath('entrypoint.js'),
+      toAbsolutePath('module-package', 'main.js'),
+      toAbsolutePath('module-package', 'package.json'),
+      toAbsolutePath('module', 'index.js'),
+    ])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('Should not repeat files if duplicated', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'simple-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.js'), toAbsolutePath('*.js')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.js'),
+      toAbsolutePath('dep2.js'),
+      toAbsolutePath('dep3.js'),
+      toAbsolutePath('entrypoint.js'),
+      toAbsolutePath('module-package', 'main.js'),
+      toAbsolutePath('module-package', 'package.json'),
+      toAbsolutePath('module', 'index.js'),
+      toAbsolutePath('unreachable.js'),
+    ])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should not fail on a non-existing glob', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'simple-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('*.foo')])
+    expect(res.files).toHaveLength(0)
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should not fail on a non-existing file', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'simple-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('idonotexist.js')])
+    expect(res.files).toHaveLength(0)
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should not fail on a non-existing directory', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'simple-example-that-does-not-exist', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('/')])
+    expect(res.files).toHaveLength(0)
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should parse the cli in less than 400ms', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, '../../../', ...filepath)
+    const startTimestamp = Date.now().valueOf()
+    const res = await new Parser({}).getFilesAndDependencies([toAbsolutePath('/index.ts')])
+    const endTimestamp = Date.now().valueOf()
+    expect(res.files).not.toHaveLength(0)
+    expect(res.errors).toHaveLength(0)
+    const isCI = process.env.CI === 'true'
+    expect(endTimestamp - startTimestamp).toBeLessThan(isCI ? 2000 : 400)
+  })
+
+  it('should handle JS file with dependencies glob patterns', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'simple-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('*.js'), toAbsolutePath('*.json')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.js'),
+      toAbsolutePath('dep2.js'),
+      toAbsolutePath('dep3.js'),
+      toAbsolutePath('entrypoint.js'),
+      toAbsolutePath('module-package', 'main.js'),
+      toAbsolutePath('module-package', 'package.json'),
+      toAbsolutePath('module', 'index.js'),
+      toAbsolutePath('unreachable.js'),
+    ])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should report a missing entrypoint file', async () => {
+    const missingEntrypoint = path.join(__dirname, 'check-parser-fixtures', 'does-not-exist.js')
+    try {
+      const parser = new Parser({})
+      await parser.getFilesAndDependencies([missingEntrypoint])
+    } catch (err) {
+      expect(err).toMatchObject({ missingFiles: [missingEntrypoint] })
+    }
+  })
+
+  it('should report missing check dependencies', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', ...filepath)
+    try {
+      const parser = new Parser({})
+      await parser.getFilesAndDependencies([toAbsolutePath('missing-dependencies.js')])
+    } catch (err) {
+      expect(err).toMatchObject({ missingFiles: [toAbsolutePath('does-not-exist.js'), toAbsolutePath('does-not-exist2.js')] })
+    }
+  })
+
+  it('should report syntax errors', async () => {
+    const entrypoint = path.join(__dirname, 'check-parser-fixtures', 'syntax-error.js')
+    try {
+      const parser = new Parser({})
+      await parser.getFilesAndDependencies([entrypoint])
+    } catch (err) {
+      expect(err).toMatchObject({ parseErrors: [{ file: entrypoint, error: 'Unexpected token (4:70)' }] })
+    }
+  })
+
+  it('should report unsupported dependencies', async () => {
+    const entrypoint = path.join(__dirname, 'check-parser-fixtures', 'unsupported-dependencies.js')
+    try {
+      const parser = new Parser({})
+      await parser.getFilesAndDependencies([entrypoint])
+    } catch (err) {
+      expect(err).toMatchObject({ unsupportedNpmDependencies: [{ file: entrypoint, unsupportedDependencies: ['left-pad', 'right-pad'] }] })
+    }
+  })
+
+  it('should handle circular dependencies', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'circular-dependencies', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.js')])
+
+    // Circular dependencies are allowed in Node.js
+    // We just need to test that parsing the dependencies doesn't loop indefinitely
+    // https://nodejs.org/api/modules.html#modules_cycles
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.js'),
+      toAbsolutePath('dep2.js'),
+      toAbsolutePath('entrypoint.js'),
+    ])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should parse typescript dependencies', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'typescript-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.ts')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.ts'),
+      toAbsolutePath('dep2.ts'),
+      toAbsolutePath('dep3.ts'),
+      toAbsolutePath('dep4.js'),
+      toAbsolutePath('dep5.ts'),
+      toAbsolutePath('dep6.ts'),
+      toAbsolutePath('entrypoint.ts'),
+      toAbsolutePath('module-package', 'main.js'),
+      toAbsolutePath('module-package', 'package.json'),
+      toAbsolutePath('module', 'index.ts'),
+      toAbsolutePath('pages/external.first.page.js'),
+      toAbsolutePath('pages/external.second.page.ts'),
+      toAbsolutePath('type.ts'),
+    ])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should parse typescript dependencies using tsconfig', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'tsconfig-paths-sample-project', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('src', 'entrypoint.ts')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('lib1', 'file1.ts'),
+      toAbsolutePath('lib1', 'file2.ts'),
+      toAbsolutePath('lib1', 'folder', 'file1.ts'),
+      toAbsolutePath('lib1', 'folder', 'file2.ts'),
+      toAbsolutePath('lib1', 'index.ts'),
+      toAbsolutePath('lib1', 'package.json'),
+      toAbsolutePath('lib1', 'tsconfig.json'),
+      toAbsolutePath('lib2', 'index.ts'),
+      toAbsolutePath('lib3', 'foo', 'bar.ts'),
+      toAbsolutePath('src', 'entrypoint.ts'),
+      toAbsolutePath('tsconfig.json'),
+    ])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should not include tsconfig if not needed', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'tsconfig-paths-unused', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('src', 'entrypoint.ts')])
+    expect(res.files.sort()).toEqual([toAbsolutePath('src', 'entrypoint.ts')])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should support importing ts extensions if allowed', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'tsconfig-allow-importing-ts-extensions', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('src', 'entrypoint.ts')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('src', 'dep1.ts'),
+      toAbsolutePath('src', 'dep2.ts'),
+      toAbsolutePath('src', 'dep3.ts'),
+      toAbsolutePath('src', 'entrypoint.ts'),
+    ])
+    expect(res.errors).toHaveLength(0)
+  })
+
+  it('should not import TS files from a JS file', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'no-import-ts-from-js', ...filepath)
+    const parser = new Parser({})
+    expect.assertions(1)
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.js')])
+    } catch (err) {
+      expect(err).toMatchObject({
+        missingFiles: [
+          toAbsolutePath('dep1'),
+          toAbsolutePath('dep1.ts'),
+          toAbsolutePath('dep1.js'),
+        ],
+      })
+    }
+  })
+
+  it('should import JS files from a TS file', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'import-js-from-ts', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.ts')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.js'),
+      toAbsolutePath('dep2.js'),
+      toAbsolutePath('dep3.ts'),
+      toAbsolutePath('entrypoint.ts'),
+    ])
+  })
+
+  it('should handle ES Modules', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'esmodules-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.js')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.js'),
+      toAbsolutePath('dep2.js'),
+      toAbsolutePath('dep3.js'),
+      toAbsolutePath('dep5.js'),
+      toAbsolutePath('dep6.js'),
+      toAbsolutePath('entrypoint.js'),
+    ])
+  })
+
+  it('should handle Common JS and ES Modules', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'common-esm-example', ...filepath)
+    const parser = new Parser({})
+    const res = await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.mjs')])
+    expect(res.files.sort()).toEqual([
+      toAbsolutePath('dep1.js'),
+      toAbsolutePath('dep2.mjs'),
+      toAbsolutePath('dep3.mjs'),
+      toAbsolutePath('dep4.mjs'),
+      toAbsolutePath('dep5.mjs'),
+      toAbsolutePath('dep6.mjs'),
+      toAbsolutePath('entrypoint.mjs'),
+    ])
+  })
+
+  it('should handle node: prefix for built-ins', async () => {
+    const toAbsolutePath = (...filepath: string[]) => path.join(__dirname, 'check-parser-fixtures', 'builtin-with-node-prefix', ...filepath)
+    const parser = new Parser({})
+    await parser.getFilesAndDependencies([toAbsolutePath('entrypoint.ts')])
+  })
+
+  /*
+   * There is an unhandled edge-case when require() is reassigned.
+   * Even though the check might execute fine, we throw an error for a missing dependency.
+   * We could address this by keeping track of assignments as we walk the AST.
+   */
+  it.skip('should ignore cases where require is reassigned', async () => {
+    const entrypoint = path.join(__dirname, 'check-parser-fixtures', 'reassign-require.js')
+    const parser = new Parser({})
+    await parser.getFilesAndDependencies([entrypoint])
+  })
+
+  // Checks run on Checkly are wrapped to support top level await.
+  // For consistency with checks created via the UI, the CLI should support this as well.
+  it('should allow top-level await', async () => {
+    const entrypoint = path.join(__dirname, 'check-parser-fixtures', 'top-level-await.js')
+    const parser = new Parser({})
+    await parser.getFilesAndDependencies([entrypoint])
+  })
+
+  it('should allow top-level await in TypeScript', async () => {
+    const entrypoint = path.join(__dirname, 'check-parser-fixtures', 'top-level-await.ts')
+    const parser = new Parser({})
+    await parser.getFilesAndDependencies([entrypoint])
+  })
+})