joi 8.4.2 → 9.0.0-0

package/test/binary.js

@@ -0,0 +1,190 @@
+'use strict';
+
+// Load modules
+
+const Lab = require('lab');
+const Code = require('code');
+const Joi = require('../lib');
+const Helper = require('./helper');
+
+
+// Declare internals
+
+const internals = {};
+
+
+// Test shortcuts
+
+const lab = exports.lab = Lab.script();
+const describe = lab.describe;
+const it = lab.it;
+const expect = Code.expect;
+
+
+describe('binary', () => {
+
+    it('converts a string to a buffer', (done) => {
+
+        Joi.binary().validate('test', (err, value) => {
+
+            expect(err).to.not.exist();
+            expect(value instanceof Buffer).to.equal(true);
+            expect(value.length).to.equal(4);
+            expect(value.toString('utf8')).to.equal('test');
+            done();
+        });
+    });
+
+    it('validates allowed buffer content', (done) => {
+
+        const hello = new Buffer('hello');
+        const schema = Joi.binary().valid(hello);
+
+        Helper.validate(schema, [
+            ['hello', true],
+            [hello, true],
+            [new Buffer('hello'), true],
+            ['goodbye', false],
+            [new Buffer('goodbye'), false],
+            [new Buffer('HELLO'), false]
+        ], done);
+    });
+
+    describe('validate()', () => {
+
+        it('returns an error when a non-buffer or non-string is used', (done) => {
+
+            Joi.binary().validate(5, (err, value) => {
+
+                expect(err).to.exist();
+                expect(err.message).to.equal('"value" must be a buffer or a string');
+                done();
+            });
+        });
+
+        it('accepts a buffer object', (done) => {
+
+            Joi.binary().validate(new Buffer('hello world'), (err, value) => {
+
+                expect(err).to.not.exist();
+                expect(value.toString('utf8')).to.equal('hello world');
+                done();
+            });
+        });
+    });
+
+    describe('encoding()', () => {
+
+        it('applies encoding', (done) => {
+
+            const schema = Joi.binary().encoding('base64');
+            const input = new Buffer('abcdef');
+            schema.validate(input.toString('base64'), (err, value) => {
+
+                expect(err).to.not.exist();
+                expect(value instanceof Buffer).to.equal(true);
+                expect(value.toString()).to.equal('abcdef');
+                done();
+            });
+        });
+
+        it('throws when encoding is invalid', (done) => {
+
+            expect(() => {
+
+                Joi.binary().encoding('base6');
+            }).to.throw('Invalid encoding: base6');
+            done();
+        });
+    });
+
+    describe('min()', () => {
+
+        it('validates buffer size', (done) => {
+
+            const schema = Joi.binary().min(5);
+            Helper.validate(schema, [
+                [new Buffer('testing'), true],
+                [new Buffer('test'), false]
+            ], done);
+        });
+
+        it('throws when min is not a number', (done) => {
+
+            expect(() => {
+
+                Joi.binary().min('a');
+            }).to.throw('limit must be a positive integer');
+            done();
+        });
+
+        it('throws when min is not an integer', (done) => {
+
+            expect(() => {
+
+                Joi.binary().min(1.2);
+            }).to.throw('limit must be a positive integer');
+            done();
+        });
+    });
+
+    describe('max()', () => {
+
+        it('validates buffer size', (done) => {
+
+            const schema = Joi.binary().max(5);
+            Helper.validate(schema, [
+                [new Buffer('testing'), false],
+                [new Buffer('test'), true]
+            ], done);
+        });
+
+        it('throws when max is not a number', (done) => {
+
+            expect(() => {
+
+                Joi.binary().max('a');
+            }).to.throw('limit must be a positive integer');
+            done();
+        });
+
+        it('throws when max is not an integer', (done) => {
+
+            expect(() => {
+
+                Joi.binary().max(1.2);
+            }).to.throw('limit must be a positive integer');
+            done();
+        });
+    });
+
+    describe('length()', () => {
+
+        it('validates buffer size', (done) => {
+
+            const schema = Joi.binary().length(4);
+            Helper.validate(schema, [
+                [new Buffer('test'), true],
+                [new Buffer('testing'), false]
+            ], done);
+        });
+
+        it('throws when length is not a number', (done) => {
+
+            expect(() => {
+
+                Joi.binary().length('a');
+            }).to.throw('limit must be a positive integer');
+            done();
+        });
+
+        it('throws when length is not an integer', (done) => {
+
+            expect(() => {
+
+                Joi.binary().length(1.2);
+            }).to.throw('limit must be a positive integer');
+            done();
+        });
+    });
+});

package/test/boolean.js

@@ -0,0 +1,163 @@
+'use strict';
+
+// Load modules
+
+const Lab = require('lab');
+const Code = require('code');
+const Joi = require('../lib');
+const Helper = require('./helper');
+
+
+// Declare internals
+
+const internals = {};
+
+
+// Test shortcuts
+
+const lab = exports.lab = Lab.script();
+const describe = lab.describe;
+const it = lab.it;
+const expect = Code.expect;
+
+
+describe('boolean', () => {
+
+    it('converts a string to a boolean', (done) => {
+
+        Joi.boolean().validate('true', (err, value) => {
+
+            expect(err).to.not.exist();
+            expect(value).to.equal(true);
+            done();
+        });
+    });
+
+    it('errors on a number not 0 or 1', (done) => {
+
+        Joi.boolean().validate(2, (err, value) => {
+
+            expect(err).to.exist();
+            expect(value).to.equal(2);
+            done();
+        });
+    });
+
+    describe('validate()', () => {
+
+        it('converts string values and validates', (done) => {
+
+            const rule = Joi.boolean();
+            Helper.validate(rule, [
+                ['1234', false],
+                [false, true],
+                [true, true],
+                [null, false],
+                ['on', true],
+                ['off', true],
+                ['true', true],
+                ['false', true],
+                ['yes', true],
+                ['no', true],
+                ['1', true],
+                ['0', true]
+            ], done);
+        });
+
+        it('converts number values and validates', (done) => {
+
+            const rule = Joi.boolean();
+            Helper.validate(rule, [
+                [1234, false],
+                [1, true],
+                [0, true]
+            ], done);
+        });
+
+        it('converts 1 to true', (done) => {
+
+            Joi.boolean().validate(1, (err, value) => {
+
+                expect(err).to.not.exist();
+                expect(value).to.equal(true);
+                done();
+            });
+        });
+
+        it('converts 0 to false', (done) => {
+
+            Joi.boolean().validate(0, (err, value) => {
+
+                expect(err).to.not.exist();
+                expect(value).to.equal(false);
+                done();
+            });
+        });
+
+        it('should handle work with required', (done) => {
+
+            const rule = Joi.boolean().required();
+            Helper.validate(rule, [
+                ['1234', false],
+                ['true', true],
+                [false, true],
+                [true, true],
+                [null, false]
+            ], done);
+        });
+
+        it('should handle work with allow', (done) => {
+
+            const rule = Joi.boolean().allow(false);
+            Helper.validate(rule, [
+                ['1234', false],
+                [false, true],
+                [null, false]
+            ], done);
+        });
+
+        it('should handle work with invalid', (done) => {
+
+            const rule = Joi.boolean().invalid(false);
+            Helper.validate(rule, [
+                ['1234', false],
+                [false, false],
+                [true, true],
+                [null, false]
+            ], done);
+        });
+
+        it('should handle work with invalid and null allowed', (done) => {
+
+            const rule = Joi.boolean().invalid(false).allow(null);
+            Helper.validate(rule, [
+                ['1234', false],
+                [false, false],
+                [true, true],
+                [null, true]
+            ], done);
+        });
+
+        it('should handle work with allow and invalid', (done) => {
+
+            const rule = Joi.boolean().invalid(true).allow(false);
+            Helper.validate(rule, [
+                ['1234', false],
+                [false, true],
+                [true, false],
+                [null, false]
+            ], done);
+        });
+
+        it('should handle work with allow, invalid, and null allowed', (done) => {
+
+            const rule = Joi.boolean().invalid(true).allow(false).allow(null);
+            Helper.validate(rule, [
+                ['1234', false],
+                [false, true],
+                [true, false],
+                [null, true]
+            ], done);
+        });
+    });
+});