feat(oas3): add support to 'servers' in 'path item' object

Closes APIARY-6503

Author: Marco Friso

packages/fury-adapter-oas3-parser/lib/parser/oas/parsePathItemObject.js

@@ -9,12 +9,13 @@ const parseObject = require('../parseObject');
 const parseString = require('../parseString');
 const parseCopy = require('../parseCopy');
 const parseParameterObjects = require('./parseParameterObjects');
+const parseServersArray = require('./parseServersArray');
 const parseOperationObject = require('./parseOperationObject');
 const pipeParseResult = require('../../pipeParseResult');
 
 const name = 'Path Item Object';
 const httpMethods = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
-const unsupportedKeys = ['$ref', 'servers'];
+const unsupportedKeys = ['$ref'];
 
 const isHttpMethodKey = R.anyPass(R.map(hasKey, httpMethods));
 const isUnsupportedKey = R.anyPass(R.map(hasKey, unsupportedKeys));
@@ -127,6 +128,7 @@ function parsePathItemObject(context, member) {
     [hasKey('summary'), parseString(context, name, false)],
     [hasKey('description'), parseCopy(context, name, false)],
     [hasKey('parameters'), R.curry(parseParameters)(context, member.key)],
+    [hasKey('servers'), R.compose(parseServersArray(context, name), getValue)],
     [isHttpMethodKey, parseOperationObject(context, member.key)],
 
     // FIXME Parse $ref
@@ -150,6 +152,11 @@ function parsePathItemObject(context, member) {
       resource.href = hrefFromParameters(member.key, parameters);
       resource.hrefVariables = hrefVariablesFromParameters(namespace, parameters);
 
+      const hosts = pathItem.get('servers');
+      if (hosts) {
+        resource.push(hosts);
+      }
+
       const summary = pathItem.get('summary');
       if (summary) {
         resource.title = summary.clone();

packages/fury-adapter-oas3-parser/test/unit/parser/oas/parsePathItemObject-test.js

@@ -68,20 +68,6 @@ describe('Path Item Object', () => {
       expect(parseResult).to.contain.warning("'Path Item Object' contains unsupported key '$ref'");
     });
 
-    it('warns for a servers', () => {
-      const path = new namespace.elements.Member('/', {
-        servers: '',
-      });
-
-      const parseResult = parse(context, path);
-
-      expect(parseResult.length).to.equal(2);
-      expect(parseResult.get(0)).to.be.instanceof(namespace.elements.Resource);
-      expect(parseResult.get(0).href.toValue()).to.equal('/');
-
-      expect(parseResult).to.contain.warning("'Path Item Object' contains unsupported key 'servers'");
-    });
-
     it('does not provide warning for Info Object extensions', () => {
       const path = new namespace.elements.Member('/', {
         'x-extension': '',
@@ -419,4 +405,74 @@ describe('Path Item Object', () => {
       });
     });
   });
+
+  describe('#servers', () => {
+    it('warns when servers is not an array', () => {
+      const path = new namespace.elements.Member('/', {
+        servers: {},
+      });
+
+      const parseResult = parse(context, path);
+
+      expect(parseResult.length).to.equal(2);
+      expect(parseResult.get(0)).to.be.instanceof(namespace.elements.Resource);
+      expect(parseResult.get(0).href.toValue()).to.equal('/');
+
+      expect(parseResult).to.contain.warning("'Path Item Object' 'servers' is not an array");
+    });
+
+    it('exposes servers as an array in the resource', () => {
+      const path = new namespace.elements.Member('/', {
+        servers: [
+          {
+            url: 'https://{username}.server.com/1.0',
+            variables: {
+              username: {
+                default: 'Mario',
+                enum: ['Tony', 'Nina'],
+              },
+            },
+          },
+          {
+            url: 'https://user.server.com/2.0',
+            description: 'The production API server',
+          },
+        ],
+      });
+
+      const parseResult = parse(context, path);
+
+      expect(parseResult.length).to.equal(1);
+      expect(parseResult.get(0)).to.be.instanceof(namespace.elements.Resource);
+
+      const hostsCategory = parseResult.get(0).get(0);
+      expect(hostsCategory).to.be.instanceof(namespace.elements.Category);
+      expect(hostsCategory.classes.toValue()).to.deep.equal(['hosts']);
+      expect(hostsCategory.length).to.equal(2);
+
+      const firstHost = hostsCategory.get(0);
+      expect(firstHost).to.be.instanceof(namespace.elements.Resource);
+      expect(firstHost.href.toValue()).to.equal('https://{username}.server.com/1.0');
+
+      const { hrefVariables } = firstHost;
+      expect(hrefVariables).to.be.instanceof(namespace.elements.HrefVariables);
+      expect(hrefVariables.length).to.equal(1);
+
+      const hrefVariable = hrefVariables.content.content[0];
+      expect(hrefVariable).to.be.instanceof(namespace.elements.Member);
+      expect(hrefVariable.key.toValue()).to.equal('username');
+      expect(hrefVariable.value.default).to.equal('Mario');
+
+      const { enumerations } = hrefVariable.value;
+      expect(enumerations).to.be.instanceof(namespace.elements.Array);
+      expect(enumerations.length).to.equal(2);
+      expect(enumerations.toValue()).to.deep.equal(['Tony', 'Nina']);
+
+      const secondHost = hostsCategory.get(1);
+      expect(secondHost).to.be.instanceof(namespace.elements.Resource);
+      expect(secondHost.classes.toValue()).to.deep.equal(['host']);
+      expect(secondHost.description.toValue()).to.equal('The production API server');
+      expect(secondHost.href.toValue()).to.equal('https://user.server.com/2.0');
+    });
+  });
 });