added resolution of inline property allOf constructs per #459

Author: fehguy

lib/client.js

@@ -138,6 +138,10 @@ SwaggerClient.prototype.initialize = function (url, options) {
   this.progress = options.progress || function () {};
   this.spec = _.cloneDeep(options.spec); // Clone so we do not alter the provided document
 
+  if (options.scheme) {
+    this.scheme = options.scheme;
+  }
+
   if (typeof options.success === 'function') {
     this.ready = true;
     this.build();
@@ -260,9 +264,9 @@ SwaggerClient.prototype.buildFromSpec = function (response) {
 
   if (typeof this.url === 'string') {
     location = this.parseUri(this.url);
-    if (typeof this.schemes === 'undefined' || this.schemes.length === 0) {
+    if (typeof this.scheme === 'undefined' && typeof this.schemes === 'undefined' || this.schemes.length === 0) {
       this.scheme = location.scheme || 'http';
-    } else {
+    } else if (typeof this.scheme === 'undefined') {
       this.scheme = this.schemes[0];
     }
 
@@ -278,7 +282,7 @@ SwaggerClient.prototype.buildFromSpec = function (response) {
     if (typeof this.schemes === 'undefined' || this.schemes.length === 0) {
       this.scheme = 'http';
     }
-    else {
+    else if (typeof this.scheme === 'undefined') {
       this.scheme = this.schemes[0];
     }
   }

lib/resolver.js

@@ -12,6 +12,24 @@ var _ = {
  */
 var Resolver = module.exports = function () {};
 
+Resolver.prototype.processAllOf = function(name, definition, resolutionTable, unresolvedRefs, spec) {
+  var i, location, property;
+
+  definition['x-resolved-from'] = [ '#/definitions/' + name ];
+  var allOf = definition.allOf;
+  // the refs go first
+  allOf.sort(function(a, b) {
+    if(a.$ref && b.$ref) { return 0; }
+    else if(a.$ref) { return -1; }
+    else { return 1; }
+  });
+  for (i = 0; i < allOf.length; i++) {
+    property = allOf[i];
+    location = '/definitions/' + name + '/allOf';
+    this.resolveInline(null, spec, property, resolutionTable, unresolvedRefs, location);
+  }
+}
+
 Resolver.prototype.resolve = function (spec, arg1, arg2, arg3) {
   var root = arg1, callback = arg2, scope = arg3, location, i;
   if(typeof arg1 === 'function') {
@@ -32,23 +50,16 @@ Resolver.prototype.resolve = function (spec, arg1, arg2, arg3) {
     var definition = spec.definitions[name];
     for (propertyName in definition.properties) {
       property = definition.properties[propertyName];
-      this.resolveTo(root, property, resolutionTable, '/definitions');
+      if(_.isArray(property.allOf)) {
+        this.processAllOf(name, property, resolutionTable, unresolvedRefs, spec);
+      }
+      else {
+        this.resolveTo(root, property, resolutionTable, '/definitions');
+      }
     }
 
     if(definition.allOf) {
-      definition['x-resolved-from'] = [ '#/definitions/' + name ];
-      var allOf = definition.allOf;
-      // the refs go first
-      allOf.sort(function(a, b) {
-        if(a.$ref && b.$ref) { return 0; }
-        else if(a.$ref) { return -1; }
-        else { return 1; }
-      });
-      for (i = 0; i < allOf.length; i++) {
-        property = allOf[i];
-        location = '/definitions/' + name + '/allOf';
-        this.resolveInline(null, spec, property, resolutionTable, unresolvedRefs, location);
-      }
+      this.processAllOf(name, definition, resolutionTable, unresolvedRefs, spec);
     }
   }
 
@@ -461,7 +472,6 @@ Resolver.prototype.resolveInline = function (root, spec, property, resolutionTab
 
 Resolver.prototype.resolveTo = function (root, property, resolutionTable, location) {
   var ref = property.$ref;
-
   if (ref) {
     if(ref.indexOf('#') >= 0) {
       location = ref.split('#')[1];

test/auth.js

@@ -180,7 +180,6 @@ describe('2.0 authorizations', function () {
     // Mock out the request, will only allow one request
     fauxjax.once('request', function (req) {
 
-      console.log('req', req);
       expect(req.requestHeaders).to.include.keys('auth');
       expect(req.requestHeaders.auth).to.equal('val');
 

test/composition.js

@@ -227,4 +227,112 @@ describe('swagger resolver', function () {
     });
   });
 
+  it('resolves a model with a composed response array', function (done) {
+    var api = new Resolver();
+    var spec = {
+      paths: {
+        "/test": {
+          get: {
+            responses: {
+              200: {
+                schema: {
+                  type: "array",
+                  items: {
+                    $ref: "#/definitions/Response"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      definitions: {
+        Request: {
+        properties: {
+          name: {
+            type: "string"
+          }
+        }
+      },
+      Response: {
+        allOf: [
+          {
+            $ref: "#/definitions/Request"
+          },
+          {
+            properties: {
+              id: {
+                description: "ID of entry",
+                type: "integer"
+              }
+            }
+          }
+        ]
+        }
+      }
+    };
+
+    api.resolve(spec, 'http://localhost:8000/v2/petstore.json', function (spec, unresolved) {
+      expect(Object.keys(unresolved).length).toBe(0);
+      test.object(spec);
+      done();
+    });
+  });
+
+  it('tests issue #459', function (done) {
+    var api = new Resolver();
+    var spec = {
+      definitions: {
+        new_model: {
+          properties: {
+            subclass: {
+              allOf: [
+                {
+                  $ref: "#/definitions/superclass"
+                },
+                {
+                  properties: {
+                    name: {
+                      type: "string"
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        },
+        superclass: {
+          properties: {
+            id: {
+              format: "int32",
+              type: "integer"
+            }
+          }
+        }
+      }
+    };
+    api.resolve(spec, 'http://localhost:8000/v2/petstore.json', function (spec, unresolved) {
+      expect(Object.keys(unresolved).length).toBe(0);
+      test.object(spec);
+      var schema = spec.definitions.new_model.properties.subclass;
+
+      expect(schema['x-composed']).toBe(true);
+      expect(Array.isArray(schema['x-resolved-from'])).toBe(true);
+      expect(schema['x-resolved-from'][0]).toBe('#/definitions/new_model');
+      expect(schema['x-resolved-from'][1]).toBe('#/definitions/superclass');
+
+      expect(Object.keys(schema.properties).length).toBe(2);
+
+      var id = schema.properties.id;
+      expect(id.type).toBe("integer");
+      expect(id.format).toBe("int32");
+      expect(id['x-resolved-from']).toBe('#/definitions/superclass');
+
+      var name = schema.properties.name;
+      expect(name.type).toBe("string");
+      expect(name['x-resolved-from']).toBe('self');
+
+      done();
+    });
+  });
 });