Rename tests to match their implementation directory structure

lib/__tests__/body-parsing.js → lib/__tests__/index.js

@@ -167,4 +167,86 @@ describe('Body Parsing', () => {
         .send('message=lol');
     });
   });
+
+  describe('Nested Query Strings', () => {
+    describe('when options.qs = false', () => {
+      test('should not support nested query strings', () => {
+        const app = koala();
+        app.use(function * (next) {
+          this.response.body = this.request.query;
+        });
+
+        return request(app.callback())
+          .get('/')
+          .query({
+            something: {
+              nested: true
+            }
+          })
+          .expect(200)
+          .expect({
+            'something[nested]': 'true'
+          });
+      });
+    });
+
+    describe('when options.qs = true', () => {
+      test('should support nested query strings', () => {
+        const app = koala({
+          qs: true
+        });
+        app.use(function * (next) {
+          this.response.body = this.request.query;
+        });
+
+        return request(app.callback())
+          .get('/')
+          .query({
+            something: {
+              nested: true
+            }
+          })
+          .expect(200)
+          .expect({
+            something: {
+              nested: 'true'
+            }
+          });
+      });
+    });
+  });
+
+  describe('jsonp', () => {
+    test('should return jsonp response', () => {
+      const app = koala({
+        jsonp: {
+          callback: '_callback'
+        }
+      });
+      app.use(function * (next) {
+        this.jsonp = {foo: 'bar'};
+      });
+
+      return request(app.callback())
+        .get('/user.json?_callback=fn')
+        .expect(200)
+        .expect('/**/ typeof fn === \'function\' && fn({"foo":"bar"});');
+    });
+
+    test('should return json response', () => {
+      const app = koala({
+        jsonp: {
+          callback: '_callback'
+        }
+      });
+      app.use(function * (next) {
+        this.jsonp = {foo: 'bar'};
+      });
+
+      return request(app.callback())
+        .get('/user.json')
+        .expect(200)
+        .expect({'foo': 'bar'});
+    });
+  });
 });

lib/__tests__/conditional-get.js → lib/middleware/__tests__/conditional-get.js

@@ -1,4 +1,4 @@
-const koala = require('..');
+const koala = require('../..');
 const request = require('supertest');
 
 describe('Conditional-Get', () => {

lib/__tests__/headers.js → lib/middleware/__tests__/headers.js

@@ -1,33 +1,7 @@
-const koala = require('..');
+const koala = require('../..');
 const request = require('supertest');
 
 describe('Set headers', () => {
-  describe('X-Response-Time', () => {
-    test('should get X-Response-Time correctly by default', () => {
-      const app = koala();
-
-      return request(app.callback())
-        .get('/')
-        .expect(404)
-        .expect('X-Response-Time', /s$/);
-    });
-    test(
-      'should not get X-Response-Time by options.responseTime = false',
-      () => {
-        const app = koala({
-          responseTime: false
-        });
-
-        return request(app.callback())
-          .get('/')
-          .expect(404)
-          .expect(res => {
-            expect(res.headers['X-Response-Time']).toBe(undefined);
-          });
-      }
-    );
-  });
-
   describe('Strict-Transport-Security', () => {
     test('should not set Strict-Transport-Security by default', () => {
       const app = koala();

lib/middleware/__tests__/index.js

@@ -0,0 +1,88 @@
+const koala = require('../..');
+const request = require('supertest');
+const PassThrough = require('stream').PassThrough;
+
+describe('Middlewares', () => {
+  describe('Response Time', () => {
+    test('should get X-Response-Time correctly by default', () => {
+      const app = koala();
+
+      return request(app.callback())
+        .get('/')
+        .expect(404)
+        .expect('X-Response-Time', /s$/);
+    });
+    test(
+      'should not get X-Response-Time by options.responseTime = false',
+      () => {
+        const app = koala({
+          responseTime: false
+        });
+
+        return request(app.callback())
+          .get('/')
+          .expect(404)
+          .expect(res => {
+            expect(res.headers['X-Response-Time']).toBe(undefined);
+          });
+      }
+    );
+  });
+
+  describe('Object Streams', () => {
+    test('should be supported', () => {
+      const app = koala();
+      app.use(function * (next) {
+        const body = this.body = new PassThrough({
+          objectMode: true
+        });
+
+        body.write({
+          message: 'a'
+        });
+
+        body.write({
+          message: 'b'
+        });
+
+        body.end();
+      });
+
+      return request(app.callback())
+        .get('/')
+        .expect(200)
+        .expect([{
+          message: 'a'
+        }, {
+          message: 'b'
+        }]);
+    });
+  });
+
+  describe('Session', () => {
+    test('should has this.session by default', () => {
+      const app = koala();
+
+      app.use(function * () {
+        this.body = this.session;
+      });
+
+      return request(app.callback())
+        .get('/')
+        .expect('{}');
+    });
+    test('should has no this.session by options.session = false', () => {
+      const app = koala({
+        session: false
+      });
+
+      app.use(function * () {
+        this.body = this.session === undefined;
+      });
+
+      return request(app.callback())
+        .get('/')
+        .expect('true');
+    });
+  });
+});