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

Closes APIARY-6502

Author: Marco Friso

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

@@ -13,6 +13,7 @@ const parseObject = require('../parseObject');
 const parseString = require('../parseString');
 const parseResponsesObject = require('./parseResponsesObject');
 const parseParameterObjects = require('./parseParameterObjects');
+const parseServersArray = require('./parseServersArray');
 const parseRequestBodyObject = require('./parseRequestBodyObject');
 const parseSecurityRequirementsArray = require('./parseSecurityRequirementsArray');
 const parseReference = require('../parseReference');
@@ -110,6 +111,7 @@ function parseOperationObject(context, path, member) {
     [hasKey('responses'), R.compose(parseResponsesObject(context), getValue)],
     [hasKey('requestBody'), R.compose(parseRequestBodyObjectOrRef(context), getValue)],
     [hasKey('parameters'), R.compose(parseParameterObjects(context, name), getValue)],
+    [hasKey('servers'), R.compose(parseServersArray(context, name), getValue)],
     [hasKey('security'), R.compose(parseSecurityRequirementsArray(context), getValue)],
 
     [isUnsupportedKey, createUnsupportedMemberWarning(namespace, name)],
@@ -163,6 +165,8 @@ function parseOperationObject(context, path, member) {
         }
       }
 
+      transition.hosts = operation.get('servers');
+
       const security = operation.get('security');
       if (security) {
         transactions.forEach((transaction) => {

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

@@ -494,6 +494,77 @@ describe('Operation Object', () => {
     });
   });
 
+  describe('#servers', () => {
+    it('warns when servers is not an array', () => {
+      const operation = new namespace.elements.Member('get', {
+        servers: {},
+        responses: {},
+      });
+
+      const parseResult = parse(context, path, operation);
+
+      expect(parseResult.length).to.equal(2);
+      expect(parseResult.get(0)).to.be.instanceof(namespace.elements.Transition);
+
+      expect(parseResult).to.contain.warning("'Operation Object' 'servers' is not an array");
+    });
+
+    it('exposes servers as an array in the transition', () => {
+      const operation = new namespace.elements.Member('get', {
+        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',
+          },
+        ],
+        responses: {},
+      });
+
+      const parseResult = parse(context, path, operation);
+
+      expect(parseResult.length).to.equal(1);
+      expect(parseResult.get(0)).to.be.instanceof(namespace.elements.Transition);
+
+      const hostsCategory = parseResult.get(0).hosts;
+      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');
+    });
+  });
+
   describe('#security', () => {
     it('parses correctly when there is a security requirement', () => {
       const operation = new namespace.elements.Member('get', {