fix: check all locations if in is not specified.

src/context.spec.ts

@@ -157,7 +157,7 @@ describe('#getData()', () => {
 
       context.addFieldInstances(data);
 
-      expect(context.getData()).toEqual([data[0]]);
+      expect(context.getData()).toEqual(data);
     });
 
     it('does not filter out second undefined when it contains a wildcard', () => {

src/context.ts

@@ -43,12 +43,12 @@ export class Context {
         const locations = _.uniqBy(instances, 'location');
 
         // #331 - When multiple locations are involved, all of them must pass the validation.
-        // If none of the locations contain the field, we at least include one for error reporting.
+        // checkSchema: If `in` option is not specified, try to check all locations by default.
         // #458, #531 - Wildcards are an exception though: they may yield 0..* instances with different
         // paths, so we may want to skip this filtering.
         if (instances.length > 1 && locations.length > 1 && !group.includes('*')) {
           const withValue = instances.filter(instance => instance.value !== undefined);
-          return withValue.length ? withValue : [instances[0]];
+          return withValue.length ? withValue : instances;
         }
 
         return instances;

src/middlewares/schema.spec.ts

@@ -183,12 +183,49 @@ describe('on each field', () => {
     const { context } = await chain.run({ params: { foo: '' } });
     expect(context.errors).toHaveLength(1);
   });
+
+  it('use default config when specified', async () => {
+    const chain = checkSchema({
+      undef: {
+        default: {
+          options: 10,
+        },
+      },
+    })[0];
+
+    const req = { query: { undef: undefined }, body: {}, params: {}, headers: {}, cookies: {} };
+    const { context } = await chain.run(req);
+
+    expect(context.getData().every(instance => instance.value === 10)).toBe(true);
+    expect(req.query.undef).toBe(10);
+    expect((req as any).body.undef).toBe(10);
+    expect((req as any).headers.undef).toBe(10);
+    expect((req as any).params.undef).toBe(10);
+    expect((req as any).cookies.undef).toBe(10);
+  });
 });
 
+describe('when ParamSchema location not specified', () => {
+  it('should validate locations only in which the field can be found', async () => {
+    const schema = checkSchema({
+      foo: {
+        isInt: true,
+        toInt: true,
+      },
+    });
+    const { context } = await schema[0].run({
+      query: { foo: 'foo' },
+      params: { foo: 'true' },
+    });
+
+    expect(context.errors).toHaveLength(2);
+  });
+});
 describe('on schema that contains fields with bail methods', () => {
-  it('stops validation chain with only one error', async () => {
+  it('stops validation chain with only one error with specified location', async () => {
     const schema = checkSchema({
       foo: {
+        in: ['params'],
         exists: {
           bail: true,
         },
@@ -200,7 +237,57 @@ describe('on schema that contains fields with bail methods', () => {
       },
     });
 
-    const { context } = await schema[0].run({ params: {} });
+    const { context } = await schema[0].run({ query: {} });
+    expect(context.errors).toHaveLength(1);
+  });
+
+  it('stops validation chain if any validation fails with "exist" validator', async () => {
+    const allLocations = ['body', 'cookies', 'headers', 'params', 'query'];
+    const schema = checkSchema({
+      foo: {
+        exists: {
+          bail: true,
+          errorMessage: 'exists checking failed',
+        },
+        isLength: {
+          options: {
+            min: 5,
+          },
+        },
+      },
+    });
+
+    const { context } = await schema[0].run({ query: {} });
+    // when location is not specified, checking each location one by one,
+    // if the expected field does not show up at all in any location, then there will be 5 errors.
+    // finally bails.
+    expect(context.errors).toHaveLength(allLocations.length);
+    // context.errors should not contain any error from next validator -> isLength.
+    expect(context.errors.every(err => err.msg === 'exists checking failed')).toBe(true);
+  });
+
+  it('stops validation chain if any validation fails with sanitizer', async () => {
+    const schema = checkSchema({
+      foo: {
+        toInt: true,
+        isInt: {
+          bail: true,
+        },
+        isLength: {
+          options: {
+            min: 5,
+          },
+        },
+      },
+    });
+
+    const { context } = await schema[0].run({ query: { foo: 'true' } });
+    const {
+      errors: [firstError],
+    } = context;
+
+    // simply make sure it's sanitizer-result-caused error.
+    expect(firstError.value).toBe(NaN);
     expect(context.errors).toHaveLength(1);
   });
 
@@ -225,6 +312,7 @@ describe('on schema that contains fields with bail methods', () => {
   it('bails with message', async () => {
     const schema = checkSchema({
       foo: {
+        in: ['params'],
         exists: {
           bail: true,
           errorMessage: 'Value not exists',

src/middlewares/validation-chain-builders.spec.ts

@@ -48,6 +48,23 @@ describe('buildCheckFunction()', () => {
       value: 'asd',
     });
   });
+
+  describe('when at least 1 locations specified', () => {
+    // for #1010
+    it('should apply default value to each specified location if default option is not empty', async () => {
+      const custom = buildCheckFunction(['cookies', 'headers']);
+      const chain = custom('bar').default(10);
+
+      await chain.run(req);
+
+      expect(req.cookies).toHaveProperty('bar', 10);
+      expect(req.headers).toHaveProperty('bar', 10);
+
+      expect(req.body).not.toHaveProperty('bar');
+      expect(req.params).not.toHaveProperty('bar');
+      expect(req.query).not.toHaveProperty('bar');
+    });
+  });
 });
 
 describe('check()', () => {