feat: SL-2035 cli url spec (#200)

karol-maciaszek · web-flow · commit 76ae24fe0d7a · 2019-03-20T08:27:31.000+01:00
* feat: SL-2035 passing url as spec in cli

* feat: SL-2035 various fixes

* fix: SL-2035 fixed test

* fix: SL-2035 post review changes

* test: SL-2035 added few tests for CLI to increase coverage
diff --git a/packages/cli/src/commands/__tests__/__snapshots__/serve.func.ts.snap b/packages/cli/src/commands/__tests__/__snapshots__/serve.func.ts.snap
diff --git a/packages/cli/src/commands/__tests__/serve.func.ts b/packages/cli/src/commands/__tests__/serve.func.ts
diff --git a/packages/cli/src/commands/__tests__/serve.unit.ts b/packages/cli/src/commands/__tests__/serve.unit.ts
@@ -0,0 +1,38 @@
+import { httpLoaderInstance } from '@stoplight/prism-core';
+import { createServer } from '@stoplight/prism-http-server';
+import Serve from '../serve';
+
+const listenMock = jest.fn();
+
+jest.mock('@stoplight/prism-core');
+jest.mock('@stoplight/prism-http-server', () => ({
+  createServer: jest.fn(() => ({ listen: listenMock })),
+}));
+
+describe('serve command', () => {
+  beforeEach(() => {
+    (createServer as jest.Mock).mockClear();
+  });
+
+  test('starts filesystem server variant', async () => {
+    await Serve.run(['-s', '/path/to']);
+
+    expect(createServer).toHaveBeenLastCalledWith(
+      { path: '/path/to' },
+      { components: { config: { mock: false } } }
+    );
+
+    expect(listenMock).toHaveBeenLastCalledWith(4010);
+  });
+
+  test('starts http server variant', async () => {
+    await Serve.run(['-s', 'http://path.to/spec.oas2.yaml']);
+
+    expect(createServer).toHaveBeenLastCalledWith(
+      { url: 'http://path.to/spec.oas2.yaml' },
+      { components: { config: { mock: false }, loader: httpLoaderInstance } }
+    );
+
+    expect(listenMock).toHaveBeenLastCalledWith(4010);
+  });
+});
diff --git a/packages/cli/src/commands/serve.ts b/packages/cli/src/commands/serve.ts
@@ -1,7 +1,6 @@
 import { Command, flags as oflags } from '@oclif/command';
-import { TPrismHttpComponents } from '@stoplight/prism-http';
+import { httpLoaderInstance } from '@stoplight/prism-core';
 import { createServer } from '@stoplight/prism-http-server';
-import { existsSync, statSync } from 'fs';
 
 export default class Serve extends Command {
   public static description = 'Start a server with the given spec file';
@@ -23,35 +22,24 @@ export default class Serve extends Command {
   };
 
   public async run() {
-    const { flags } = this.parse(Serve);
-    const { port, spec, mock } = flags;
+    const {
+      flags: { spec, mock, port },
+    } = this.parse(Serve);
+
+    const server =
+      spec && isHttp(spec)
+        ? createServer(
+            { url: spec },
+            { components: { config: { mock }, loader: httpLoaderInstance } }
+          )
+        : createServer({ path: spec }, { components: { config: { mock } } });
 
-    await this.validateSpecPath(spec);
-
-    const components: TPrismHttpComponents<any> = !mock ? { config: { mock: false } } : {};
-    const server = createServer({ path: spec }, { components });
     const address = await server.listen(port as number);
 
     this.log(address);
   }
+}
 
-  private validateSpecPath(path?: string) {
-    if (!path) {
-      return;
-    }
-
-    if (!existsSync(path)) {
-      this.error(`Non-existing path to spec supplied: ${path}`);
-      this.exit(0x01);
-      return;
-    }
-
-    const stats = statSync(path);
-
-    if (stats.isDirectory()) {
-      this.error(`Supplied spec path points to directory. Only files are supported.`);
-      this.exit(0x02);
-      return;
-    }
-  }
+function isHttp(spec: string) {
+  return !!spec.match(/^https?:\/\//);
 }
diff --git a/packages/core/package.json b/packages/core/package.json
@@ -17,6 +17,7 @@
   },
   "dependencies": {
     "@stoplight/graphite": "3.5.x",
+    "axios": "0.x.x",
     "lodash": "4.x.x",
     "tslib": "1.9.x"
   },
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -1,4 +1,5 @@
 export * from './types';
 export * from './factory';
 export * from './loaders/filesystem';
+export * from './loaders/http';
 export * from './utils';
diff --git a/packages/core/src/loaders/filesystem/__tests__/__snapshots__/filesystemLoader.unit.ts.snap b/packages/core/src/loaders/filesystem/__tests__/__snapshots__/filesystemLoader.unit.ts.snap
@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`filesystemLoader throws error when supplied with a directory 1`] = `"Non-existing path to spec supplied: a path"`;
+
+exports[`filesystemLoader throws error when supplied with non-existing path 1`] = `"Supplied spec path points to directory. Only files are supported."`;
diff --git a/packages/core/src/loaders/filesystem/__tests__/filesystemLoader.unit.ts b/packages/core/src/loaders/filesystem/__tests__/filesystemLoader.unit.ts
@@ -1,6 +1,8 @@
-import { FilesystemLoader } from '../../../../src';
-jest.mock('../../../../src/utils/graphFacade');
-import { GraphFacade } from '../../../../src/utils/graphFacade';
+import * as fs from 'fs';
+import { FilesystemLoader } from '../';
+import { GraphFacade } from '../../../utils/graphFacade';
+jest.mock('../../../utils/graphFacade');
+jest.mock('fs');
 
 describe('filesystemLoader', () => {
   const fakeHttpOperations = ['a', 'b', 'c'];
@@ -11,12 +13,15 @@ describe('filesystemLoader', () => {
     graphFacadeMock = new GraphFacade();
     createFileSystemNodeMock = graphFacadeMock.createFilesystemNode as jest.Mock;
     createFileSystemNodeMock.mockResolvedValue(true);
+
     Object.defineProperty(graphFacadeMock, 'httpOperations', {
       get: jest.fn().mockReturnValue(fakeHttpOperations),
     });
   });
 
   test('given no opts should delegate to graph facade for http operations', async () => {
+    jest.spyOn(fs, 'existsSync').mockReturnValueOnce(true);
+    jest.spyOn(fs, 'statSync').mockReturnValueOnce({ isDirectory: () => false });
     const filesystemLoader = new FilesystemLoader(graphFacadeMock);
 
     const operations = await filesystemLoader.load();
@@ -26,11 +31,27 @@ describe('filesystemLoader', () => {
   });
 
   test('given opts should delegate to graph facade for http operations', async () => {
+    jest.spyOn(fs, 'existsSync').mockReturnValueOnce(true);
+    jest.spyOn(fs, 'statSync').mockReturnValueOnce({ isDirectory: () => false });
+
     const filesystemLoader = new FilesystemLoader(graphFacadeMock);
 
     const operations = await filesystemLoader.load({ path: 'a path' });
 
     expect(createFileSystemNodeMock).toHaveBeenCalledWith('a path');
     expect(operations).toBe(fakeHttpOperations);
   });
+
+  it('throws error when supplied with non-existing path', async () => {
+    jest.spyOn(fs, 'existsSync').mockReturnValueOnce(true);
+    jest.spyOn(fs, 'statSync').mockReturnValueOnce({ isDirectory: () => true });
+    const filesystemLoader = new FilesystemLoader(graphFacadeMock);
+    return expect(filesystemLoader.load({ path: 'a path' })).rejects.toThrowErrorMatchingSnapshot();
+  });
+
+  it('throws error when supplied with a directory', async () => {
+    jest.spyOn(fs, 'existsSync').mockReturnValueOnce(false);
+    const filesystemLoader = new FilesystemLoader(graphFacadeMock);
+    return expect(filesystemLoader.load({ path: 'a path' })).rejects.toThrowErrorMatchingSnapshot();
+  });
 });
diff --git a/packages/core/src/loaders/filesystem/filesystemLoader.ts b/packages/core/src/loaders/filesystem/filesystemLoader.ts
@@ -1,4 +1,5 @@
 import { IHttpOperation } from '@stoplight/types';
+import { existsSync, statSync } from 'fs';
 import { IFilesystemLoaderOpts } from '../../types';
 import { GraphFacade } from '../../utils/graphFacade';
 
@@ -12,8 +13,20 @@ export class FilesystemLoader {
    * There is no way to filter by a type in runtime :(
    */
   public async load(/*<Resource>*/ _opts?: IFilesystemLoaderOpts): Promise<IHttpOperation[]> {
-    const fsPath = _opts ? _opts.path : DEFAULT_PATH;
+    const fsPath = _opts && _opts.path ? _opts.path : DEFAULT_PATH;
+
+    if (!existsSync(fsPath)) {
+      throw new Error(`Non-existing path to spec supplied: ${fsPath}`);
+    }
+
+    const stats = statSync(fsPath);
+
+    if (stats.isDirectory()) {
+      throw new Error(`Supplied spec path points to directory. Only files are supported.`);
+    }
+
     await this.graphFacade.createFilesystemNode(fsPath);
+
     return this.graphFacade.httpOperations;
   }
 }
diff --git a/packages/core/src/loaders/http/__tests__/httpLoader.unit.ts b/packages/core/src/loaders/http/__tests__/httpLoader.unit.ts
@@ -0,0 +1,27 @@
+import { HttpLoader } from '../';
+jest.mock('../../../utils/graphFacade');
+jest.mock('axios');
+import axios from 'axios';
+import { GraphFacade } from '../../../utils/graphFacade';
+
+describe('httpLoader', () => {
+  const fakeHttpOperations = ['a', 'b', 'c'];
+  let graphFacadeMock: any;
+
+  beforeEach(() => {
+    graphFacadeMock = new GraphFacade();
+    Object.defineProperty(graphFacadeMock, 'httpOperations', {
+      get: jest.fn().mockReturnValue(fakeHttpOperations),
+    });
+    ((axios as unknown) as jest.Mock).mockResolvedValue({ data: 'a data' });
+  });
+
+  test('given no opts should delegate to graph facade for http operations', async () => {
+    const httpLoader = new HttpLoader(graphFacadeMock);
+
+    const operations = await httpLoader.load({ url: 'a url' });
+
+    expect(axios).toHaveBeenCalledWith({ url: 'a url', transformResponse: expect.any(Function) });
+    expect(operations).toBe(fakeHttpOperations);
+  });
+});
diff --git a/packages/core/src/loaders/http/httpLoader.ts b/packages/core/src/loaders/http/httpLoader.ts
@@ -0,0 +1,26 @@
+import { FilesystemNodeType } from '@stoplight/graphite/backends/filesystem';
+import { IHttpOperation } from '@stoplight/types';
+import axios from 'axios';
+import trimStart = require('lodash/trimStart');
+import { extname } from 'path';
+import { IHttpLoaderOpts } from '../../types';
+import { GraphFacade } from '../../utils/graphFacade';
+
+export class HttpLoader {
+  constructor(private graphFacade: GraphFacade) {}
+
+  public async load(opts?: IHttpLoaderOpts): Promise<IHttpOperation[]> {
+    if (!opts || !opts.url) return [];
+
+    const response = await axios({ url: opts.url, transformResponse: d => d });
+
+    await this.graphFacade.createRawNode(response.data, {
+      type: FilesystemNodeType.File,
+      subtype: trimStart(extname(opts.url), '.'),
+    });
+
+    return this.graphFacade.httpOperations;
+  }
+}
+
+export const httpLoaderInstance = new HttpLoader(new GraphFacade());
diff --git a/packages/core/src/loaders/http/index.ts b/packages/core/src/loaders/http/index.ts
@@ -0,0 +1 @@
+export * from './httpLoader';
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
@@ -46,6 +46,10 @@ export interface IFilesystemLoaderOpts {
   path?: string;
 }
 
+export interface IHttpLoaderOpts {
+  url?: string;
+}
+
 export interface IRouter<Resource, Input, Config> {
   route: (
     opts: { resources: Resource[]; input: Input; config?: Config },
diff --git a/packages/core/src/utils/__tests__/__snapshots__/graphFacade.int.ts.snap b/packages/core/src/utils/__tests__/__snapshots__/graphFacade.int.ts.snap
@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`graphFacade httpOperations should return filtered nodes 1`] = `
+exports[`graphFacade createFilesystemNode() httpOperations should return filtered nodes 1`] = `
 Array [
   Object {
     "deprecated": undefined,
diff --git a/packages/core/src/utils/__tests__/graphFacade.int.ts b/packages/core/src/utils/__tests__/graphFacade.int.ts
@@ -1,21 +1,35 @@
+import { FilesystemNodeType } from '@stoplight/graphite/backends/filesystem';
 import { isAbsolute, resolve } from 'path';
 import { GraphFacade } from '../graphFacade';
 
 describe('graphFacade', () => {
   const graphFacade = new GraphFacade();
 
-  test('httpOperations should return filtered nodes', async () => {
-    await graphFacade.createFilesystemNode('packages/cli/src/samples/no-refs-petstore.oas2.json');
+  describe('createFilesystemNode()', () => {
+    test('httpOperations should return filtered nodes', async () => {
+      await graphFacade.createFilesystemNode('packages/cli/src/samples/no-refs-petstore.oas2.json');
 
-    expect(graphFacade.httpOperations).toMatchSnapshot();
-  });
+      expect(graphFacade.httpOperations).toMatchSnapshot();
+    });
+
+    test('handles spec given by absolute path', async () => {
+      const path = resolve('packages/cli/src/samples/no-refs-petstore.oas2.json');
+      expect(isAbsolute(path)).toBe(true);
 
-  test('handles spec given by absolute path', async () => {
-    const path = resolve('packages/cli/src/samples/no-refs-petstore.oas2.json');
-    expect(isAbsolute(path)).toBe(true);
+      await graphFacade.createFilesystemNode(path);
+
+      expect(graphFacade.httpOperations.length).toBeGreaterThan(0);
+    });
+  });
 
-    await graphFacade.createFilesystemNode(path);
+  describe('createRawNode()', () => {
+    test('httpOperations should return filtered nodes', async () => {
+      await graphFacade.createRawNode(
+        JSON.stringify(require('../../../../cli/src/samples/no-refs-petstore.oas2.json')),
+        { type: FilesystemNodeType.File, subtype: 'json' }
+      );
 
-    expect(graphFacade.httpOperations.length).toBeGreaterThan(0);
+      expect(graphFacade.httpOperations.length).toBeGreaterThan(0);
+    });
   });
 });
diff --git a/packages/core/src/utils/graphFacade.ts b/packages/core/src/utils/graphFacade.ts
diff --git a/packages/tsconfig.json b/packages/tsconfig.json
