add tests

lets see if we're there :)

Author: osher

test/assets/project/api/controllers/overrides_ctrl_interface_pipe.js

@@ -0,0 +1,18 @@
+module.exports = {
+  pipeInterface:       pipeInterface,
+  middlewareInterface: middlewareInterface
+}
+
+function pipeInterface(ctx, next) {
+  ctx.statusCode = 200;
+  ctx.headers = { 
+    'content-type': 'application/json',
+    'x-interface': 'pipe'
+  };
+  next(null, { interface: 'pipe' });
+}
+
+function middlewareInterface(req, res, next) {
+  res.setHeader('x-interface', 'middleware');
+  res.json({ interface: "middleware" });
+}

test/assets/project/api/swagger/swagger.yaml

@@ -314,6 +314,45 @@ paths:
             content-type:
               type: integer
           schema: {}
+  /controller_interface_auto_detected_as_pipe:
+    x-swagger-router-controller: overrides_ctrl_interface_pipe
+    x-controller-interface: auto-detect
+    get:
+      description: well, what do you know...
+      operationId: pipeInterface
+      responses: 
+        200: 
+          description: Whatever
+          schema: {}
+  /controller_interface_auto_detected_as_middleware:
+    x-swagger-router-controller: overrides_ctrl_interface_pipe
+    x-controller-interface: auto-detect
+    get:
+      description: well, what do you know...
+      operationId: middlewareInterface
+      responses: 
+        200: 
+          description: Whatever
+          schema: {}
+  /controller_interface_on_path_cascades:
+    x-swagger-router-controller: overrides_ctrl_interface_pipe
+    x-controller-interface: pipe
+    get: 
+      operationId: pipeInterface
+      responses: 
+        200: 
+          description: Whatever
+          schema: {}
+  /controller_interface_on_operation_cascades:
+    x-swagger-router-controller: overrides_ctrl_interface_pipe
+    x-controller-interface: pipe
+    get: 
+      x-controller-interface: middleware
+      operationId: middlewareInterface
+      responses: 
+        200: 
+          description: Whatever
+          schema: {}
 definitions:
   HelloWorldResponse:
     type: object

test/assets/project/config_auto/default.yaml

@@ -0,0 +1,39 @@
+# values in the swagger hash are system configuration for swagger-node
+swagger:
+
+  fittingsDirs: [ api/fittings ]
+  defaultPipe: null
+  swaggerControllerPipe: swagger_controllers  # defines the standard processing pipe for controllers
+
+  # values defined in the bagpipes key are the bagpipes pipes and fittings definitions
+  # (see https://github.com/apigee-127/bagpipes)
+  bagpipes:
+
+    _router:
+      name: swagger_router
+      mockMode: false
+      mockControllersDirs: [ api/mocks ]
+      controllersDirs: [ api/controllers ]
+      controllersInterface: auto-detect
+
+    _swagger_validate:
+      name: swagger_validator
+      validateResponse: true
+
+    _swagger_security:
+      name: swagger_security
+      securityHandlersModule: api/helpers/securityHandlers
+
+    # pipe for all swagger-node controllers
+    swagger_controllers:
+      - onError: json_error_handler
+      - cors
+      - swagger_params_parser
+      - _swagger_security
+      - _swagger_validate
+      - express_compatibility
+      - _router
+
+    # pipe to serve swagger (endpoint is in swagger.yaml)
+    swagger_raw:
+      name: swagger_raw

test/fittings/swagger_raw.js

@@ -20,7 +20,7 @@ describe('swagger_raw', function() {
     delete(filteredSwagger.paths['/invalid_header']);
 
     // hokey algorithm, but at least it's different than the one it's testing
-    var OMIT = ['x-swagger-router-controller', 'x-swagger-pipe', 'x-hidden', 'x-private'];
+    var OMIT = ['x-swagger-router-controller', 'x-swagger-pipe', 'x-hidden', 'x-private', 'x-controller-interface'];
     _.forEach(filteredSwagger.paths, function(element, name) {
       filteredSwagger.paths[name] = _.omit(element, OMIT);
       _.forEach(filteredSwagger.paths[name], function(element, subName) {

test/index.js

@@ -156,10 +156,9 @@ describe('index', function() {
         delete process.env.NODE_CONFIG_DIR;
     });
 
-    it('should use the configured router interface', function(done) {
+    it('should use pipe interface when _router.controllersInterface is set to `pipe`', function(done) {
       var config = _.clone(DEFAULT_PROJECT_CONFIG);
-      
-      process.env.NODE_CONFIG_DIR = path.resolve(DEFAULT_PROJECT_ROOT, "config_pipe");
+      config.configDir = path.resolve(DEFAULT_PROJECT_ROOT, "config_pipe");
 
       SwaggerRunner.create(config, function(err, runner) {
         if (err) { return done(err); }
@@ -181,8 +180,116 @@ describe('index', function() {
             done();
           });
       });        
-     
     });
+    
+    it('should use pipe interface when _router.controllersInterface is set to `auto` and operation.length is 2', function(done) {
+      var config = _.clone(DEFAULT_PROJECT_CONFIG);
+      config.configDir = path.resolve(DEFAULT_PROJECT_ROOT, "config_auto");
+      
+      SwaggerRunner.create(config, function(err, runner) {
+        if (err) { return done(err); }
+        runner.config.swagger.bagpipes.should.have.property('swagger_controllers');
+
+        var app = require('connect')();
+        runner.connectMiddleware().register(app);
+
+        var request = require('supertest');
+
+        request(app)
+          .get('/controller_interface_auto_detected_as_pipe')
+          .set('Accept', 'application/json')
+          .expect(200)
+          .expect('Content-Type', /json/)
+          .expect('x-interface', /pipe/)
+          .end(function(err, res) {
+            should.not.exist(err, err && err.stack);
+            res.body.should.eql({ interface: "pipe" });
+            done();
+          });
+      });        
+    });
+    
+    it('should use middleware interface when _router.controllersInterface is set to `auto` and operation.length is 3', function(done) {
+      var config = _.clone(DEFAULT_PROJECT_CONFIG);
+      config.configDir = path.resolve(DEFAULT_PROJECT_ROOT, "config_auto");
+      
+      SwaggerRunner.create(config, function(err, runner) {
+        if (err) { return done(err); }
+        runner.config.swagger.bagpipes.should.have.property('swagger_controllers');
+
+        var app = require('connect')();
+        runner.connectMiddleware().register(app);
+
+        var request = require('supertest');
+
+        request(app)
+          .get('/controller_interface_auto_detected_as_middleware')
+          .set('Accept', 'application/json')
+          .expect(200)
+          .expect('Content-Type', /json/)
+          .expect('x-interface', /middleware/)
+          .end(function(err, res) {
+            should.not.exist(err, err && err.stack);
+            res.body.should.eql({ interface: "middleware" });
+            done();
+          });
+      });        
+    });
+    
+    it('should use adhere to cascading directgive `x-interface-type` found on path', function(done) {
+      var config = _.clone(DEFAULT_PROJECT_CONFIG);
+      config.configDir = path.resolve(DEFAULT_PROJECT_ROOT, "config_auto");
+      
+      SwaggerRunner.create(config, function(err, runner) {
+        if (err) { return done(err); }
+        runner.config.swagger.bagpipes.should.have.property('swagger_controllers');
+
+        var app = require('connect')();
+        runner.connectMiddleware().register(app);
+
+        var request = require('supertest');
+
+        request(app)
+          .get('/controller_interface_on_path_cascades')
+          .set('Accept', 'application/json')
+          .expect(200)
+          .expect('Content-Type', /json/)
+          .expect('x-interface', /pipe/)
+          .end(function(err, res) {
+            should.not.exist(err, err && err.stack);
+            res.body.should.eql({ interface: "pipe" });
+            done();
+          });
+      });        
+    });
+
+    it('should use adhere to cascading directgive `x-interface-type` found on operation over one found on path', function(done) {
+      var config = _.clone(DEFAULT_PROJECT_CONFIG);
+      config.configDir = path.resolve(DEFAULT_PROJECT_ROOT, "config_auto");
+      
+      SwaggerRunner.create(config, function(err, runner) {
+        if (err) { return done(err); }
+        runner.config.swagger.bagpipes.should.have.property('swagger_controllers');
+
+        var app = require('connect')();
+        runner.connectMiddleware().register(app);
+
+        var request = require('supertest');
+
+        request(app)
+          .get('/controller_interface_on_operation_cascades')
+          .set('Accept', 'application/json')
+          .expect(200)
+          .expect('Content-Type', /json/)
+          .expect('x-interface', /middleware/)
+          .end(function(err, res) {
+            should.not.exist(err, err && err.stack);
+            res.body.should.eql({ interface: "middleware" });
+            done();
+          });
+      });        
+    });     
+    
 
     it('should fail without callback', function() {
       (function() { SwaggerRunner.create(DEFAULT_PROJECT_CONFIG) }).should.throw('callback is required');