Merge remote-tracking branch 'upstream/master' into issue-995

Author: bodnia

package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger-client",
-  "version": "3.0.5",
+  "version": "3.0.6",
   "description": "SwaggerJS - a collection of interfaces for OAI specs",
   "main": "dist/index.js",
   "contributors": [

src/execute.js

@@ -186,17 +186,19 @@ export function queryBuilder({req, value, parameter}) {
   }
 }
 
+const stripNonAlpha = str => (str ? str.replace(/\W/g, '') : null)
+
 // Compose the baseUrl ( scheme + host + basePath )
 export function baseUrl({spec, scheme, contextUrl = ''}) {
-  const {host, basePath, schemes = ['http']} = spec
-
-  const parsedUrl = url.parse(contextUrl)
+  const parsedContextUrl = url.parse(contextUrl)
+  const firstSchemeInSpec = Array.isArray(spec.schemes) ? spec.schemes[0] : null
 
-  let applyScheme = ['http', 'https'].indexOf(scheme) > -1 ? scheme : schemes[0]
-  applyScheme = applyScheme ? `${applyScheme}:` : ''
+  const computedScheme = scheme || firstSchemeInSpec || stripNonAlpha(parsedContextUrl.protocol) || 'http'
+  const computedHost = spec.host || parsedContextUrl.host || ''
+  const computedPath = spec.basePath || ''
 
-  if (host || basePath || contextUrl) {
-    let res = `${applyScheme}//${host || parsedUrl.host || ''}${basePath || ''}`
+  if (computedScheme && computedHost) {
+    const res = `${computedScheme}://${computedHost + computedPath}`
 
     // If last character is '/', trim it off
     return res[res.length - 1] === '/' ? res.slice(0, -1) : res

test/execute-baseurl.js

@@ -0,0 +1,137 @@
+import expect, {createSpy, spyOn} from 'expect'
+import xmock from 'xmock'
+import {execute, buildRequest, baseUrl, applySecurities, self as stubs} from '../src/execute'
+
+// Supported shape...  { spec, operationId, parameters, securities, fetch }
+// One can use operationId or pathItem + method
+
+describe('baseUrl', () => {
+
+  describe('with contextUrl', () => {
+
+  })
+
+  it('should calculate a valid baseUrl given host, basePath, context, schemes', () => {
+    const res = baseUrl({
+      spec: {
+        schemes: ['https'],
+        host: 'foo.com:8080',
+        basePath: '/bar'
+      },
+      contextUrl: 'http://example.com:9090/hello/swagger.json'
+    })
+
+    expect(res).toEqual('https://foo.com:8080/bar')
+  })
+
+  it('should calculate a valid baseUrl given host, basePath, context', () => {
+    const res = baseUrl({
+      spec: {
+        host: 'foo.com:8080',
+        basePath: '/bar'
+      },
+      contextUrl: 'http://example.com:9090/hello/swagger.json'
+    })
+
+    expect(res).toEqual('http://foo.com:8080/bar')
+  })
+
+  it('should trim the trailing slash when basePath is "/"', () => {
+    const res = baseUrl({
+      spec: {
+        host: 'foo.com:8080',
+        basePath: '/'
+      }
+    })
+
+    expect(res).toEqual('http://foo.com:8080')
+  })
+
+  it('should infer the host and port based on the contextUrl', () => {
+    const res = baseUrl({
+      spec: {
+        basePath: '/bar'
+      },
+      contextUrl: "http://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("http://example.com:9090/bar")
+  })
+
+  it('should infer the entire url based on the contextUrl', () => {
+    const res = baseUrl({
+      spec: {},
+      contextUrl: "http://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("http://example.com:9090")
+  })
+
+  it('should infer the host based on the contextUrl', () => {
+    const res = baseUrl({
+      spec: {
+        schemes: ['https'],
+        basePath: '/bar'
+      },
+      contextUrl: "http://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("https://example.com:9090/bar")
+  })
+
+  it('should default to an empty basePath', () => {
+    const res = baseUrl({
+      spec: {
+        schemes: ['https'],
+        host: 'foo.com:8080'
+      },
+      contextUrl: "http://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("https://foo.com:8080")
+  })
+
+  it('should default to the correct scheme based on the spec', () => {
+    const res = baseUrl({
+      spec: {
+        schemes: ['https']
+      },
+      contextUrl: "http://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("https://example.com:9090")
+  })
+
+  it('should default to HTTP scheme based on the contextUrl', () => {
+    const res = baseUrl({
+      spec: {
+        host: 'foo.com:8080'
+      },
+      contextUrl: "http://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("http://foo.com:8080")
+  })
+
+  it('should default to HTTPS scheme based on the contextUrl', () => {
+    const res = baseUrl({
+      spec: {
+        host: 'foo.com:8080'
+      },
+      contextUrl: "https://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("https://foo.com:8080")
+  })
+
+  it('should default to HTTPS scheme and host based on the contextUrl', () => {
+    const res = baseUrl({
+      spec: {
+        title: 'a spec'
+      },
+      contextUrl: "https://example.com:9090/hello/swagger.json"
+    })
+
+    expect(res).toEqual("https://example.com:9090")
+  })
+})

test/execute.js

@@ -1552,110 +1552,4 @@ describe('execute', () => {
       })
     })
   })
-
-  describe('baseUrl', () => {
-    let contextUrl = "http://example.com:9090/hello/swagger.json"
-
-    it('should calculate a valid baseUrl given host, basePath, context, schemes', () => {
-      let res = baseUrl({
-        spec: {
-          schemes: ["https"],
-          host: "foo.com:8080",
-          basePath: "/bar"
-        },
-        contextUrl
-      })
-
-      expect(res).toEqual("https://foo.com:8080/bar")
-    })
-
-    it('should calculate a valid baseUrl given host, basePath, context', () => {
-      let res = baseUrl({
-        spec: {
-          host: "foo.com:8080",
-          basePath: "/bar"
-        },
-        contextUrl
-      })
-
-      expect(res).toEqual("http://foo.com:8080/bar")
-    })
-
-    it('should trim the trailing slash when basePath is "/"', () => {
-      let res = baseUrl({
-        spec: {
-          host: "foo.com:8080",
-          basePath: "/"
-        }
-      })
-
-      expect(res).toEqual("http://foo.com:8080")
-    })
-
-    it('should infer the host and port based on the contextUrl', () => {
-      let res = baseUrl({
-        spec: {
-          basePath: "/bar"
-        },
-        contextUrl
-      })
-
-      expect(res).toEqual("http://example.com:9090/bar")
-    })
-
-    it('should infer the entire url based on the contextUrl', () => {
-      let res = baseUrl({
-        spec: {},
-        contextUrl
-      })
-
-      expect(res).toEqual("http://example.com:9090")
-    })
-
-    it('should infer the host based on the contextUrl', () => {
-      let res = baseUrl({
-        spec: {
-          schemes: ['https'],
-          basePath: '/bar'
-        },
-        contextUrl
-      })
-
-      expect(res).toEqual("https://example.com:9090/bar")
-    })
-
-    it('should default to an empty basePath', () => {
-      let res = baseUrl({
-        spec: {
-          schemes: ['https'],
-          host: 'foo.com:8080'
-        },
-        contextUrl
-      })
-
-      expect(res).toEqual("https://foo.com:8080")
-    })
-
-    it('should default to the correct scheme based on the spec', () => {
-      let res = baseUrl({
-        spec: {
-          schemes: ['https']
-        },
-        contextUrl
-      })
-
-      expect(res).toEqual("https://example.com:9090")
-    })
-
-    it('should default to the correct scheme based on the spec', () => {
-      let res = baseUrl({
-        spec: {
-          host: 'foo.com:8080'
-        },
-        contextUrl
-      })
-
-      expect(res).toEqual("http://foo.com:8080")
-    })
-  })
 })