How to use createType method in storybook-root

Best JavaScript code snippet using storybook-root

test_schemas.js

Source:test_schemas.js

...60 }61 ];62 testType(types.IntType, data);63 test('toBuffer int', function () {64 var type = createType('int');65 assert.equal(type.fromBuffer(new Buffer([0x80, 0x01])), 64);66 assert(new Buffer([0]).equals(type.toBuffer(0)));67 });68 test('resolve int > long', function () {69 var intType = createType('int');70 var longType = createType('long');71 var buf = intType.toBuffer(123);72 assert.equal(73 longType.fromBuffer(buf, longType.createResolver(intType)),74 12375 );76 });77 test('resolve int > [null, int]', function () {78 var wt = createType('int');79 var rt = createType(['null', 'int']);80 var buf = wt.toBuffer(123);81 assert.deepEqual(82 rt.fromBuffer(buf, rt.createResolver(wt)),83 {'int': 123}84 );85 });86 test('resolve int > float', function () {87 var wt = createType('int');88 var rt = createType('float');89 var buf = wt.toBuffer(123);90 assert.deepEqual(rt.fromBuffer(buf, rt.createResolver(wt)), 123);91 });92 test('resolve int > double', function () {93 var wt = createType('int');94 var rt = createType('double');95 var n = Math.pow(2, 30) + 1;96 var buf = wt.toBuffer(n);97 assert.deepEqual(rt.fromBuffer(buf, rt.createResolver(wt)), n);98 });99 test('toString', function () {100 assert.equal(createType('int').toString(), '"int"');101 });102 test('clone', function () {103 var t = createType('int');104 assert.equal(t.clone(123), 123);105 assert.throws(function () { t.clone(''); });106 });107 test('resolve invalid', function () {108 assert.throws(function () { getResolver('int', 'long'); });109 });110 });111 suite('LongType', function () {112 var data = [113 {114 valid: [1, -3, 12314, 9007199254740990, 900719925474090],115 invalid: [null, 'hi', undefined, 9007199254740991, 1.3, 1e67]116 }117 ];118 testType(types.LongType, data);119 test('resolve invalid', function () {120 assert.throws(function () { getResolver('long', 'double'); });121 });122 test('resolve long > float', function () {123 var t1 = createType('long');124 var t2 = createType('float');125 var n = 9007199254740990; // Number.MAX_SAFE_INTEGER - 1126 var buf = t1.toBuffer(n);127 var f = t2.fromBuffer(buf, t2.createResolver(t1));128 assert(Math.abs(f - n) / n < 1e-7);129 assert(t2.isValid(f));130 });131 test('precision loss', function () {132 var type = createType('long');133 var buf = new Buffer([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x20]);134 assert.throws(function () { type.fromBuffer(buf); });135 });136 test('using missing methods', function () {137 assert.throws(function () { types.LongType.using(); });138 });139 });140 suite('StringType', function () {141 var data = [142 {143 valid: ['', 'hi'],144 invalid: [null, undefined, 1, 0]145 }146 ];147 testType(types.StringType, data);148 test('fromBuffer string', function () {149 var type = createType('string');150 var buf = new Buffer([0x06, 0x68, 0x69, 0x21]);151 var s = 'hi!';152 assert.equal(type.fromBuffer(buf), s);153 assert(buf.equals(type.toBuffer(s)));154 });155 test('toBuffer string', function () {156 var type = createType('string');157 var buf = new Buffer([0x06, 0x68, 0x69, 0x21]);158 assert(buf.equals(type.toBuffer('hi!', 1)));159 });160 test('resolve string > bytes', function () {161 var stringT = createType('string');162 var bytesT = createType('bytes');163 var buf = stringT.toBuffer('\x00\x01');164 assert.deepEqual(165 bytesT.fromBuffer(buf, bytesT.createResolver(stringT)),166 new Buffer([0, 1])167 );168 });169 test('encode resize', function () {170 var t = createType('string');171 var s = 'hello';172 var b, pos;173 b = new Buffer(2);174 pos = t.encode(s, b);175 assert(pos < 0);176 b = new Buffer(2 - pos);177 pos = t.encode(s, b);178 assert(pos >= 0);179 assert.equal(s, t.fromBuffer(b)); // Also checks exact length match.180 });181 });182 suite('NullType', function () {183 var data = [184 {185 schema: 'null',186 valid: [null],187 invalid: [0, 1, 'hi', undefined]188 }189 ];190 testType(types.NullType, data);191 });192 suite('FloatType', function () {193 var data = [194 {195 valid: [1, -3, 123e7],196 invalid: [null, 'hi', undefined],197 check: function (a, b) { assert(floatEquals(a, b)); }198 }199 ];200 testType(types.FloatType, data);201 test('compare buffer', function () {202 var t = createType('float');203 var b1 = t.toBuffer(0.5);204 assert.equal(t.compareBuffers(b1, b1), 0);205 var b2 = t.toBuffer(-0.75);206 assert.equal(t.compareBuffers(b1, b2), 1);207 var b3 = t.toBuffer(175);208 assert.equal(t.compareBuffers(b1, b3), -1);209 });210 test('resolver double > float', function () {211 assert.throws(function () { getResolver('float', 'double'); });212 });213 test('fromString', function () {214 var t = createType('float');215 var f = t.fromString('3.1');216 assert(t.isValid(f));217 });218 test('clone from double', function () {219 var t = createType('float');220 var d = 3.1;221 var f;222 f = t.clone(d);223 assert(t.isValid(f));224 });225 });226 suite('DoubleType', function () {227 var data = [228 {229 valid: [1, -3.4, 12314e31, 5e37],230 invalid: [null, 'hi', undefined],231 check: function (a, b) { assert(floatEquals(a, b), '' + [a, b]); }232 }233 ];234 testType(types.DoubleType, data);235 test('resolver string > double', function () {236 assert.throws(function () { getResolver('double', 'string'); });237 });238 test('compare buffer', function () {239 var t = createType('double');240 var b1 = t.toBuffer(0.5);241 assert.equal(t.compareBuffers(b1, b1), 0);242 var b2 = t.toBuffer(-0.75);243 assert.equal(t.compareBuffers(b1, b2), 1);244 var b3 = t.toBuffer(175);245 assert.equal(t.compareBuffers(b1, b3), -1);246 });247 });248 suite('BytesType', function () {249 var data = [250 {251 valid: [new Buffer(1), new Buffer('abc')],252 invalid: [null, 'hi', undefined, 1, 0, -3.5]253 }254 ];255 testType(types.BytesType, data);256 test('clone', function () {257 var t = createType('bytes');258 var s = '\x01\x02';259 var buf = new Buffer(s);260 var clone;261 clone = t.clone(buf);262 assert.deepEqual(clone, buf);263 clone[0] = 0;264 assert.equal(buf[0], 1);265 assert.throws(function () { t.clone(s); });266 clone = t.clone(buf.toJSON(), {coerceBuffers: true});267 assert.deepEqual(clone, buf);268 assert.throws(function () { t.clone(1, {coerceBuffers: true}); });269 });270 test('fromString', function () {271 var t = createType('bytes');272 var s = '\x01\x02';273 var buf = new Buffer(s);274 var clone = t.fromString(JSON.stringify(s));275 assert.deepEqual(clone, buf);276 });277 test('compare', function () {278 var t = createType('bytes');279 var b1 = t.toBuffer(new Buffer([0, 2]));280 assert.equal(t.compareBuffers(b1, b1), 0);281 var b2 = t.toBuffer(new Buffer([0, 2, 3]));282 assert.equal(t.compareBuffers(b1, b2), -1);283 var b3 = t.toBuffer(new Buffer([1]));284 assert.equal(t.compareBuffers(b3, b1), 1);285 });286 });287 suite('UnionType', function () {288 var data = [289 {290 name: 'null & string',291 schema: ['null', 'string'],292 valid: [null, {string: 'hi'}],293 invalid: ['null', undefined, {string: 1}],294 check: assert.deepEqual295 },296 {297 name: 'qualified name',298 schema: ['null', {type: 'fixed', name: 'a.B', size: 2}],299 valid: [null, {'a.B': new Buffer(2)}],300 invalid: [new Buffer(2)],301 check: assert.deepEqual302 },303 {304 name: 'array int',305 schema: ['int', {type: 'array', items: 'int'}],306 valid: [{'int': 1}, {array: [1,3]}],307 invalid: [null, 2, {array: ['a']}, [4], 2],308 check: assert.deepEqual309 },310 {311 name: 'null',312 schema: ['null'],313 valid: [null],314 invalid: [{array: ['a']}, [4], 'null'],315 check: assert.deepEqual316 }317 ];318 var schemas = [319 {},320 [],321 ['null', 'null'],322 ['null', {type: 'map', values: 'int'}, {type: 'map', values: 'long'}],323 ['null', ['int', 'string']]324 ];325 testType(types.UnionType, data, schemas);326 test('getTypes', function () {327 var t = createType(['null', 'int']);328 assert.deepEqual(t.getTypes(), [createType('null'), createType('int')]);329 });330 test('instanceof Union', function () {331 var type = new types.UnionType(['null', 'int']);332 assert(type instanceof types.UnionType);333 });334 test('missing name write', function () {335 var type = new types.UnionType(['null', 'int']);336 assert.throws(function () {337 type.toBuffer({b: 'a'});338 });339 });340 test('read invalid index', function () {341 var type = new types.UnionType(['null', 'int']);342 var buf = new Buffer([1, 0]);343 assert.throws(function () { type.fromBuffer(buf); });344 });345 test('non wrapped write', function () {346 var type = new types.UnionType(['null', 'int']);347 assert.throws(function () {348 type.toBuffer(1, true);349 }, Error);350 });351 test('to JSON', function () {352 var type = new types.UnionType(['null', 'int']);353 assert.equal(JSON.stringify(type), '["null","int"]');354 });355 test('resolve int to [long, int]', function () {356 var t1 = createType('int');357 var t2 = createType(['long', 'int']);358 var a = t2.createResolver(t1);359 var buf = t1.toBuffer(23);360 assert.deepEqual(t2.fromBuffer(buf, a), {'long': 23});361 });362 test('resolve null to [null, int]', function () {363 var t1 = createType('null');364 var t2 = createType(['null', 'int']);365 var a = t2.createResolver(t1);366 assert.deepEqual(t2.fromBuffer(new Buffer(0), a), null);367 });368 test('resolve [string, int] to [long, string]', function () {369 var t1 = createType(['string', 'int']);370 var t2 = createType(['int', 'bytes']);371 var a = t2.createResolver(t1);372 var buf;373 buf = t1.toBuffer({string: 'hi'});374 assert.deepEqual(t2.fromBuffer(buf, a), {'bytes': new Buffer('hi')});375 buf = t1.toBuffer({'int': 1});376 assert.deepEqual(t2.fromBuffer(buf, a), {'int': 1});377 });378 test('clone', function () {379 var t = new types.UnionType(['null', 'int']);380 var o = {'int': 1};381 assert.strictEqual(t.clone(null), null);382 var c = t.clone(o);383 assert.deepEqual(c, o);384 c.int = 2;385 assert.equal(o.int, 1);386 assert.throws(function () { t.clone([]); });387 assert.throws(function () { t.clone(undefined); });388 });389 test('clone and wrap', function () {390 var t = createType(['string', 'int']);391 var o;392 o = t.clone('hi', {wrapUnions: true});393 assert.deepEqual(o, {'string': 'hi'});394 o = t.clone(3, {wrapUnions: true});395 assert.deepEqual(o, {'int': 3});396 assert.throws(function () { t.clone(null, {wrapUnions: 2}); });397 });398 test('invalid multiple keys', function () {399 var t = createType(['null', 'int']);400 var o = {'int': 2};401 assert(t.isValid(o));402 o.foo = 3;403 assert(!t.isValid(o));404 });405 test('clone multiple keys', function () {406 var t = createType(['null', 'int']);407 var o = {'int': 2, foo: 3};408 assert.throws(function () { t.clone(o); });409 });410 test('clone unqualified names', function () {411 var t = createType({412 name: 'Person',413 type: 'record',414 fields: [415 {name: 'id1', type: {name: 'an.Id', type: 'fixed', size: 1}},416 {name: 'id2', type: ['null', 'an.Id']}417 ]418 });419 var b = new Buffer([0]);420 var o = {id1: b, id2: {Id: b}};421 assert.deepEqual(t.clone(o), {id1: b, id2: {'an.Id': b}});422 });423 test('clone unqualified names', function () {424 var t = createType({425 name: 'Person',426 type: 'record',427 fields: [428 {name: 'id1', type: {name: 'Id', type: 'fixed', size: 1}},429 {name: 'id2', type: ['null', 'Id']}430 ]431 });432 var b = new Buffer([0]);433 var o = {id1: b, id2: {'an.Id': b}};434 assert.throws(function () { t.clone(o); });435 });436 test('compare buffers', function () {437 var t = createType(['null', 'double']);438 var b1 = t.toBuffer(null);439 assert.equal(t.compareBuffers(b1, b1), 0);440 var b2 = t.toBuffer({'double': 4});441 assert.equal(t.compareBuffers(b2, b1), 1);442 assert.equal(t.compareBuffers(b1, b2), -1);443 var b3 = t.toBuffer({'double': 6});444 assert.equal(t.compareBuffers(b3, b2), 1);445 });446 test('compare', function () {447 var t;448 t = createType(['null', 'int']);449 assert.equal(t.compare(null, {'int': 3}), -1);450 assert.equal(t.compare(null, null), 0);451 t = createType(['int', 'float']);452 assert.equal(t.compare({'int': 2}, {'float': 0.5}), -1);453 assert.equal(t.compare({'int': 20}, {'int': 5}), 1);454 });455 });456 suite('EnumType', function () {457 var data = [458 {459 name: 'single symbol',460 schema: {name: 'Foo', symbols: ['HI']},461 valid: ['HI'],462 invalid: ['HEY', null, undefined, 0]463 },464 {465 name: 'number-ish as symbol',466 schema: {name: 'Foo', symbols: ['HI', 'A0']},467 valid: ['HI', 'A0'],468 invalid: ['HEY', null, undefined, 0, 'a0']469 }470 ];471 var schemas = [472 {name: 'Foo', symbols: []},473 {name: 'Foo'},474 {symbols: ['hi']},475 {name: 'G', symbols: ['0']}476 ];477 testType(types.EnumType, data, schemas);478 test('get full name', function () {479 var t = createType({480 type: 'enum',481 symbols: ['A', 'B'],482 name: 'Letter',483 namespace: 'latin'484 });485 assert.equal(t.getName(), 'latin.Letter');486 });487 test('get aliases', function () {488 var t = createType({489 type: 'enum',490 symbols: ['A', 'B'],491 name: 'Letter',492 namespace: 'latin',493 aliases: ['Character', 'alphabet.Letter']494 });495 var aliases = t.getAliases();496 assert.deepEqual(aliases, ['latin.Character', 'alphabet.Letter']);497 aliases.push('Char');498 assert.equal(t.getAliases().length, 3);499 });500 test('get symbols', function () {501 var t = createType({type: 'enum', symbols: ['A', 'B'], name: 'Letter'});502 var symbols = t.getSymbols();503 assert.deepEqual(symbols, ['A', 'B']);504 symbols.push('Char');505 assert.equal(t.getSymbols().length, 2);506 });507 test('duplicate symbol', function () {508 assert.throws(function () {509 createType({type: 'enum', symbols: ['A', 'B', 'A'], name: 'B'});510 });511 });512 test('write invalid', function () {513 var type = createType({type: 'enum', symbols: ['A'], name: 'a'});514 assert.throws(function () {515 type.toBuffer('B');516 });517 });518 test('read invalid index', function () {519 var type = new types.EnumType({type: 'enum', symbols: ['A'], name: 'a'});520 var buf = new Buffer([2]);521 assert.throws(function () { type.fromBuffer(buf); });522 });523 test('resolve', function () {524 var t1, t2, buf, resolver;525 t1 = newEnum('Foo', ['bar', 'baz']);526 t2 = newEnum('Foo', ['bar', 'baz']);527 resolver = t1.createResolver(t2);528 buf = t2.toBuffer('bar');529 assert.equal(t1.fromBuffer(buf, resolver), 'bar');530 t2 = newEnum('Foo', ['baz', 'bar']);531 buf = t2.toBuffer('bar');532 resolver = t1.createResolver(t2);533 assert.notEqual(t1.fromBuffer(buf), 'bar');534 assert.equal(t1.fromBuffer(buf, resolver), 'bar');535 t1 = newEnum('Foo2', ['foo', 'baz', 'bar'], ['Foo']);536 resolver = t1.createResolver(t2);537 assert.equal(t1.fromBuffer(buf, resolver), 'bar');538 t2 = newEnum('Foo', ['bar', 'bax']);539 assert.throws(function () { t1.createResolver(t2); });540 assert.throws(function () {541 t1.createResolver(createType('int'));542 });543 function newEnum(name, symbols, aliases, namespace) {544 var obj = {type: 'enum', name: name, symbols: symbols};545 if (aliases !== undefined) {546 obj.aliases = aliases;547 }548 if (namespace !== undefined) {549 obj.namespace = namespace;550 }551 return new types.EnumType(obj);552 }553 });554 test('clone', function () {555 var t = createType({type: 'enum', name: 'Foo', symbols: ['bar', 'baz']});556 assert.equal(t.clone('bar'), 'bar');557 assert.throws(function () { t.clone('BAR'); });558 assert.throws(function () { t.clone(null); });559 });560 test('compare buffers', function () {561 var t = createType({type: 'enum', name: 'Foo', symbols: ['bar', 'baz']});562 var b1 = t.toBuffer('bar');563 var b2 = t.toBuffer('baz');564 assert.equal(t.compareBuffers(b1, b1), 0);565 assert.equal(t.compareBuffers(b2, b1), 1);566 });567 test('compare', function () {568 var t = createType({type: 'enum', name: 'Foo', symbols: ['b', 'a']});569 assert.equal(t.compare('b', 'a'), -1);570 assert.equal(t.compare('a', 'a'), 0);571 });572 });573 suite('FixedType', function () {574 var data = [575 {576 name: 'size 1',577 schema: {name: 'Foo', size: 2},578 valid: [new Buffer([1, 2]), new Buffer([2, 3])],579 invalid: ['HEY', null, undefined, 0, new Buffer(1), new Buffer(3)],580 check: function (a, b) { assert(a.equals(b)); }581 }582 ];583 var schemas = [584 {name: 'Foo', size: 0},585 {name: 'Foo', size: -2},586 {size: 2},587 {name: 'Foo'},588 {}589 ];590 testType(types.FixedType, data, schemas);591 test('get full name', function () {592 var t = createType({593 type: 'fixed',594 size: 2,595 name: 'Id',596 namespace: 'id'597 });598 assert.equal(t.getName(), 'id.Id');599 });600 test('get aliases', function () {601 var t = createType({602 type: 'fixed',603 size: 3,604 name: 'Id'605 });606 var aliases = t.getAliases();607 assert.deepEqual(aliases, []);608 aliases.push('ID');609 assert.equal(t.getAliases().length, 1);610 });611 test('get size', function () {612 var t = createType({type: 'fixed', size: 5, name: 'Id'});613 assert.equal(t.getSize(), 5);614 });615 test('resolve', function () {616 var t1 = new types.FixedType({name: 'Id', size: 4});617 var t2 = new types.FixedType({name: 'Id', size: 4});618 assert.doesNotThrow(function () { t2.createResolver(t1); });619 t2 = new types.FixedType({name: 'Id2', size: 4});620 assert.throws(function () { t2.createResolver(t1); });621 t2 = new types.FixedType({name: 'Id2', size: 4, aliases: ['Id']});622 assert.doesNotThrow(function () { t2.createResolver(t1); });623 t2 = new types.FixedType({name: 'Id2', size: 5, aliases: ['Id']});624 assert.throws(function () { t2.createResolver(t1); });625 });626 test('clone', function () {627 var t = new types.FixedType({name: 'Id', size: 2});628 var s = '\x01\x02';629 var buf = new Buffer(s);630 var clone;631 clone = t.clone(buf);632 assert.deepEqual(clone, buf);633 clone[0] = 0;634 assert.equal(buf[0], 1);635 assert.throws(function () { t.clone(s); });636 clone = t.clone(buf.toJSON(), {coerceBuffers: true});637 assert.deepEqual(clone, buf);638 assert.throws(function () { t.clone(1, {coerceBuffers: true}); });639 assert.throws(function () { t.clone(new Buffer([2])); });640 });641 test('getSchema with extra fields', function () {642 var t = createType({type: 'fixed', name: 'Id', size: 2, three: 3});643 t.one = 1;644 assert.equal(t.getSchema(), '{"name":"Id","type":"fixed","size":2}');645 assert.equal(t.getSchema(true), '"Id"');646 });647 test('fromString', function () {648 var t = new types.FixedType({name: 'Id', size: 2});649 var s = '\x01\x02';650 var buf = new Buffer(s);651 var clone = t.fromString(JSON.stringify(s));652 assert.deepEqual(clone, buf);653 });654 test('compare buffers', function () {655 var t = createType({type: 'fixed', name: 'Id', size: 2});656 var b1 = new Buffer([1, 2]);657 assert.equal(t.compareBuffers(b1, b1), 0);658 var b2 = new Buffer([2, 2]);659 assert.equal(t.compareBuffers(b1, b2), -1);660 });661 });662 suite('MapType', function () {663 var data = [664 {665 name: 'int',666 schema: {values: 'int'},667 valid: [{one: 1}, {two: 2, o: 0}],668 invalid: [1, {o: null}, [], undefined, {o: 'hi'}, {1: '', 2: 3}, ''],669 check: assert.deepEqual670 },671 {672 name: 'enum',673 schema: {values: {type: 'enum', name: 'a', symbols: ['A', 'B']}},674 valid: [{a: 'A'}, {a: 'A', b: 'B'}, {}],675 invalid: [{o: 'a'}, {1: 'A', 2: 'b'}, {a: 3}],676 check: assert.deepEqual677 },678 {679 name: 'array of string',680 schema: {values: {type: 'array', items: 'string'}},681 valid: [{a: []}, {a: ['A'], b: ['B', '']}, {}],682 invalid: [{o: 'a', b: []}, {a: [1, 2]}, {a: {b: ''}}],683 check: assert.deepEqual684 }685 ];686 var schemas = [687 {},688 {values: ''},689 {values: {type: 'array'}}690 ];691 testType(types.MapType, data, schemas);692 test('get values type', function () {693 var t = new types.MapType({type: 'map', values: 'int'});694 assert.deepEqual(t.getValuesType(), createType('int'));695 });696 test('write int', function () {697 var t = new types.MapType({type: 'map', values: 'int'});698 var buf = t.toBuffer({'\x01': 3, '\x02': 4});699 assert.deepEqual(buf, new Buffer([4, 2, 1, 6, 2, 2, 8, 0]));700 });701 test('read long', function () {702 var t = new types.MapType({type: 'map', values: 'long'});703 var buf = new Buffer([4, 2, 1, 6, 2, 2, 8, 0]);704 assert.deepEqual(t.fromBuffer(buf), {'\x01': 3, '\x02': 4});705 });706 test('read with sizes', function () {707 var t = new types.MapType({type: 'map', values: 'int'});708 var buf = new Buffer([1,6,2,97,2,0]);709 assert.deepEqual(t.fromBuffer(buf), {a: 1});710 });711 test('skip', function () {712 var v1 = createType({713 name: 'Foo',714 type: 'record',715 fields: [716 {name: 'map', type: {type: 'map', values: 'int'}},717 {name: 'val', type: 'int'}718 ]719 });720 var v2 = createType({721 name: 'Foo',722 type: 'record',723 fields: [{name: 'val', type: 'int'}]724 });725 var b1 = new Buffer([2,2,97,2,0,6]); // Without sizes.726 var b2 = new Buffer([1,6,2,97,2,0,6]); // With sizes.727 var resolver = v2.createResolver(v1);728 assert.deepEqual(v2.fromBuffer(b1, resolver), {val: 3});729 assert.deepEqual(v2.fromBuffer(b2, resolver), {val: 3});730 });731 test('resolve int > long', function () {732 var t1 = new types.MapType({type: 'map', values: 'int'});733 var t2 = new types.MapType({type: 'map', values: 'long'});734 var resolver = t2.createResolver(t1);735 var obj = {one: 1, two: 2};736 var buf = t1.toBuffer(obj);737 assert.deepEqual(t2.fromBuffer(buf, resolver), obj);738 });739 test('resolve double > double', function () {740 var t = new types.MapType({type: 'map', values: 'double'});741 var resolver = t.createResolver(t);742 var obj = {one: 1, two: 2};743 var buf = t.toBuffer(obj);744 assert.deepEqual(t.fromBuffer(buf, resolver), obj);745 });746 test('resolve invalid', function () {747 var t1 = new types.MapType({type: 'map', values: 'int'});748 var t2 = new types.MapType({type: 'map', values: 'string'});749 assert.throws(function () { t2.createResolver(t1); });750 t2 = new types.ArrayType({type: 'array', items: 'string'});751 assert.throws(function () { t2.createResolver(t1); });752 });753 test('resolve fixed', function () {754 var t1 = createType({755 type: 'map', values: {name: 'Id', type: 'fixed', size: 2}756 });757 var t2 = createType({758 type: 'map', values: {759 name: 'Id2', aliases: ['Id'], type: 'fixed', size: 2760 }761 });762 var resolver = t2.createResolver(t1);763 var obj = {one: new Buffer([1, 2])};764 var buf = t1.toBuffer(obj);765 assert.deepEqual(t2.fromBuffer(buf, resolver), obj);766 });767 test('clone', function () {768 var t = new types.MapType({type: 'map', values: 'int'});769 var o = {one: 1, two: 2};770 var c = t.clone(o);771 assert.deepEqual(c, o);772 c.one = 3;773 assert.equal(o.one, 1);774 assert.throws(function () { t.clone(undefined); });775 });776 test('clone coerce buffers', function () {777 var t = new types.MapType({type: 'map', values: 'bytes'});778 var o = {one: {type: 'Buffer', data: [1]}};779 assert.throws(function () { t.clone(o); });780 var c = t.clone(o, {coerceBuffers: true});781 assert.deepEqual(c, {one: new Buffer([1])});782 });783 test('compare buffers', function () {784 var t = new types.MapType({type: 'map', values: 'bytes'});785 var b1 = t.toBuffer({});786 assert.throws(function () { t.compareBuffers(b1, b1); });787 });788 test('isValid hook', function () {789 var t = new types.MapType({type: 'map', values: 'int'});790 var o = {one: 1, two: 'deux', three: null, four: 4};791 var errs = {};792 assert(!t.isValid(o, {errorHook: hook}));793 assert.deepEqual(errs, {two: 'deux', three: null});794 function hook(path, obj, type) {795 assert.strictEqual(type, t.getValuesType());796 assert.equal(path.length, 1);797 errs[path[0]] = obj;798 }799 });800 test('getName', function () {801 var t = new types.MapType({type: 'map', values: 'int'});802 assert.strictEqual(t.getName(), undefined);803 });804 });805 suite('ArrayType', function () {806 var data = [807 {808 name: 'int',809 schema: {items: 'int'},810 valid: [[1,3,4], []],811 invalid: [1, {o: null}, undefined, ['a'], [true]],812 check: assert.deepEqual813 }814 ];815 var schemas = [816 {},817 {items: ''},818 ];819 testType(types.ArrayType, data, schemas);820 test('get items type', function () {821 var t = new types.ArrayType({type: 'array', items: 'int'});822 assert.deepEqual(t.getItemsType(), createType('int'));823 });824 test('read with sizes', function () {825 var t = new types.ArrayType({type: 'array', items: 'int'});826 var buf = new Buffer([1,2,2,0]);827 assert.deepEqual(t.fromBuffer(buf), [1]);828 });829 test('skip', function () {830 var v1 = createType({831 name: 'Foo',832 type: 'record',833 fields: [834 {name: 'array', type: {type: 'array', items: 'int'}},835 {name: 'val', type: 'int'}836 ]837 });838 var v2 = createType({839 name: 'Foo',840 type: 'record',841 fields: [{name: 'val', type: 'int'}]842 });843 var b1 = new Buffer([2,2,0,6]); // Without sizes.844 var b2 = new Buffer([1,2,2,0,6]); // With sizes.845 var resolver = v2.createResolver(v1);846 assert.deepEqual(v2.fromBuffer(b1, resolver), {val: 3});847 assert.deepEqual(v2.fromBuffer(b2, resolver), {val: 3});848 });849 test('resolve string items to bytes items', function () {850 var t1 = new types.ArrayType({type: 'array', items: 'string'});851 var t2 = new types.ArrayType({type: 'array', items: 'bytes'});852 var resolver = t2.createResolver(t1);853 var obj = ['\x01\x02'];854 var buf = t1.toBuffer(obj);855 assert.deepEqual(t2.fromBuffer(buf, resolver), [new Buffer([1, 2])]);856 });857 test('resolve invalid', function () {858 var t1 = new types.ArrayType({type: 'array', items: 'string'});859 var t2 = new types.ArrayType({type: 'array', items: 'long'});860 assert.throws(function () { t2.createResolver(t1); });861 t2 = new types.MapType({type: 'map', values: 'string'});862 assert.throws(function () { t2.createResolver(t1); });863 });864 test('clone', function () {865 var t = new types.ArrayType({type: 'array', items: 'int'});866 var o = [1, 2];867 var c = t.clone(o);868 assert.deepEqual(c, o);869 c.one = 3;870 assert.equal(o[0], 1);871 assert.throws(function () { t.clone({}); });872 });873 test('clone coerce buffers', function () {874 var t = createType({875 type: 'array',876 items: {type: 'fixed', name: 'Id', size: 2}877 });878 var o = [{type: 'Buffer', data: [1, 2]}];879 assert.throws(function () { t.clone(o); });880 var c = t.clone(o, {coerceBuffers: true});881 assert.deepEqual(c, [new Buffer([1, 2])]);882 });883 test('compare buffers', function () {884 var t = createType({type: 'array', items: 'int'});885 assert.equal(t.compareBuffers(t.toBuffer([]), t.toBuffer([])), 0);886 assert.equal(t.compareBuffers(t.toBuffer([1, 2]), t.toBuffer([])), 1);887 assert.equal(t.compareBuffers(t.toBuffer([1]), t.toBuffer([1, -1])), -1);888 assert.equal(t.compareBuffers(t.toBuffer([1]), t.toBuffer([2])), -1);889 assert.equal(t.compareBuffers(t.toBuffer([1, 2]), t.toBuffer([1])), 1);890 });891 test('compare', function () {892 var t = createType({type: 'array', items: 'int'});893 assert.equal(t.compare([], []), 0);894 assert.equal(t.compare([], [-1]), -1);895 assert.equal(t.compare([1], [1]), 0);896 assert.equal(t.compare([2], [1, 2]), 1);897 });898 test('isValid hook invalid array', function () {899 var t = createType({type: 'array', items: 'int'});900 var hookCalled = false;901 assert(!t.isValid({}, {errorHook: hook}));902 assert(hookCalled);903 function hook(path, obj, type) {904 assert.strictEqual(type, t);905 assert.deepEqual(path, []);906 hookCalled = true;907 }908 });909 test('isValid hook invalid elems', function () {910 var t = createType({type: 'array', items: 'int'});911 var paths = [];912 assert(!t.isValid([0, 3, 'hi', 5, 'hey'], {errorHook: hook}));913 assert.deepEqual(paths, [['2'], ['4']]);914 function hook(path, obj, type) {915 assert.strictEqual(type, t.getItemsType());916 assert.equal(typeof obj, 'string');917 paths.push(path);918 }919 });920 });921 suite('RecordType', function () {922 var data = [923 {924 name: 'union field null and string with default',925 schema: {926 type: 'record',927 name: 'a',928 fields: [{name: 'b', type: ['null', 'string'], 'default': null}]929 },930 valid: [],931 invalid: [],932 check: assert.deepEqual933 }934 ];935 var schemas = [936 {type: 'record', name: 'a', fields: ['null', 'string']},937 {type: 'record', name: 'a', fields: [{type: ['null', 'string']}]},938 {939 type: 'record',940 name: 'a',941 fields: [{name: 'b', type: ['null', 'string'], 'default': 'a'}]942 },943 {type: 'record', name: 'a', fields: {type: 'int', name: 'age'}}944 ];945 testType(types.RecordType, data, schemas);946 test('duplicate field names', function () {947 assert.throws(function () {948 createType({949 type: 'record',950 name: 'Person',951 fields: [{name: 'age', type: 'int'}, {name: 'age', type: 'float'}]952 });953 });954 });955 test('default constructor', function () {956 var type = createType({957 type: 'record',958 name: 'Person',959 fields: [{name: 'age', type: 'int', 'default': 25}]960 });961 var Person = type.getRecordConstructor();962 var p = new Person();963 assert.equal(p.age, 25);964 assert.strictEqual(p.constructor, Person);965 });966 test('default check & write', function () {967 var type = createType({968 type: 'record',969 name: 'Person',970 fields: [971 {name: 'age', type: 'int', 'default': 25},972 {name: 'name', type: 'string', 'default': '\x01'}973 ]974 });975 assert.deepEqual(type.toBuffer({}), new Buffer([50, 2, 1]));976 });977 test('fixed string default', function () {978 var s = '\x01\x04';979 var b = new Buffer(s);980 var type = createType({981 type: 'record',982 name: 'Object',983 fields: [984 {985 name: 'id',986 type: {type: 'fixed', size: 2, name: 'Id'},987 'default': s988 }989 ]990 });991 var obj = new (type.getRecordConstructor())();992 assert.deepEqual(obj.id, new Buffer([1, 4]));993 assert.deepEqual(type.toBuffer({}), b);994 });995 test('fixed buffer invalid default', function () {996 assert.throws(function () {997 createType({998 type: 'record',999 name: 'Object',1000 fields: [1001 {1002 name: 'id',1003 type: {type: 'fixed', size: 2, name: 'Id'},1004 'default': new Buffer([0])1005 }1006 ]1007 });1008 });1009 });1010 test('union invalid default', function () {1011 assert.throws(function () {1012 createType({1013 type: 'record',1014 name: 'Person',1015 fields: [{name: 'name', type: ['null', 'string'], 'default': ''}]1016 });1017 });1018 });1019 test('record default', function () {1020 var d = {street: null, zip: 123};1021 var Person = createType({1022 name: 'Person',1023 type: 'record',1024 fields: [1025 {1026 name: 'address',1027 type: {1028 name: 'Address',1029 type: 'record',1030 fields: [1031 {name: 'street', type: ['null', 'string']},1032 {name: 'zip', type: ['int', 'string']}1033 ]1034 },1035 'default': d1036 }1037 ]1038 }).getRecordConstructor();1039 var p = new Person();1040 assert.deepEqual(p.address, {street: null, zip: {'int': 123}});1041 });1042 test('record keyword field name', function () {1043 var type = createType({1044 type: 'record',1045 name: 'Person',1046 fields: [{name: 'null', type: 'int'}]1047 });1048 var Person = type.getRecordConstructor();1049 assert.deepEqual(new Person(2), {'null': 2});1050 });1051 test('record isValid', function () {1052 var type = createType({1053 type: 'record',1054 name: 'Person',1055 fields: [{name: 'age', type: 'int'}]1056 });1057 var Person = type.getRecordConstructor();1058 assert((new Person(20)).$isValid());1059 assert(!(new Person()).$isValid());1060 assert(!(new Person('a')).$isValid());1061 });1062 test('record toBuffer', function () {1063 var type = createType({1064 type: 'record',1065 name: 'Person',1066 fields: [{name: 'age', type: 'int'}]1067 });1068 var Person = type.getRecordConstructor();1069 assert.deepEqual((new Person(48)).$toBuffer(), new Buffer([96]));1070 assert.throws(function () { (new Person()).$toBuffer(); });1071 });1072 test('record compare', function () {1073 var P = createType({1074 type: 'record',1075 name: 'Person',1076 fields: [1077 {name: 'data', type: {type: 'map', values: 'int'}, order:'ignore'},1078 {name: 'age', type: 'int'}1079 ]1080 }).getRecordConstructor();1081 var p1 = new P({}, 1);1082 var p2 = new P({}, 2);1083 assert.equal(p1.$compare(p2), -1);1084 assert.equal(p2.$compare(p2), 0);1085 assert.equal(p2.$compare(p1), 1);1086 });1087 test('Record type', function () {1088 var type = createType({1089 type: 'record',1090 name: 'Person',1091 fields: [{name: 'age', type: 'int'}]1092 });1093 var Person = type.getRecordConstructor();1094 assert.strictEqual(Person.getType(), type);1095 });1096 test('mutable defaults', function () {1097 var Person = createType({1098 type: 'record',1099 name: 'Person',1100 fields: [1101 {1102 name: 'friends',1103 type: {type: 'array', items: 'string'},1104 'default': []1105 }1106 ]1107 }).getRecordConstructor();1108 var p1 = new Person(undefined);1109 assert.deepEqual(p1.friends, []);1110 p1.friends.push('ann');1111 var p2 = new Person(undefined);1112 assert.deepEqual(p2.friends, []);1113 });1114 test('resolve alias', function () {1115 var v1 = createType({1116 type: 'record',1117 name: 'Person',1118 fields: [{name: 'name', type: 'string'}]1119 });1120 var p = v1.random();1121 var buf = v1.toBuffer(p);1122 var v2 = createType({1123 type: 'record',1124 name: 'Human',1125 aliases: ['Person'],1126 fields: [{name: 'name', type: 'string'}]1127 });1128 var resolver = v2.createResolver(v1);1129 assert.deepEqual(v2.fromBuffer(buf, resolver), p);1130 var v3 = createType({1131 type: 'record',1132 name: 'Human',1133 fields: [{name: 'name', type: 'string'}]1134 });1135 assert.throws(function () { v3.createResolver(v1); });1136 });1137 test('resolve alias with namespace', function () {1138 var v1 = createType({1139 type: 'record',1140 name: 'Person',1141 namespace: 'earth',1142 fields: [{name: 'name', type: 'string'}]1143 });1144 var v2 = createType({1145 type: 'record',1146 name: 'Human',1147 aliases: ['Person'],1148 fields: [{name: 'name', type: 'string'}]1149 });1150 assert.throws(function () { v2.createResolver(v1); });1151 var v3 = createType({1152 type: 'record',1153 name: 'Human',1154 aliases: ['earth.Person'],1155 fields: [{name: 'name', type: 'string'}]1156 });1157 assert.doesNotThrow(function () { v3.createResolver(v1); });1158 });1159 test('resolve skip field', function () {1160 var v1 = createType({1161 type: 'record',1162 name: 'Person',1163 fields: [1164 {name: 'age', type: 'int'},1165 {name: 'name', type: 'string'}1166 ]1167 });1168 var p = {age: 25, name: 'Ann'};1169 var buf = v1.toBuffer(p);1170 var v2 = createType({1171 type: 'record',1172 name: 'Person',1173 fields: [{name: 'name', type: 'string'}]1174 });1175 var resolver = v2.createResolver(v1);1176 assert.deepEqual(v2.fromBuffer(buf, resolver), {name: 'Ann'});1177 });1178 test('resolve new field', function () {1179 var v1 = createType({1180 type: 'record',1181 name: 'Person',1182 fields: [{name: 'name', type: 'string'}]1183 });1184 var p = {name: 'Ann'};1185 var buf = v1.toBuffer(p);1186 var v2 = createType({1187 type: 'record',1188 name: 'Person',1189 fields: [1190 {name: 'age', type: 'int', 'default': 25},1191 {name: 'name', type: 'string'}1192 ]1193 });1194 var resolver = v2.createResolver(v1);1195 assert.deepEqual(v2.fromBuffer(buf, resolver), {name: 'Ann', age: 25});1196 });1197 test('resolve new field no default', function () {1198 var v1 = createType({1199 type: 'record',1200 name: 'Person',1201 fields: [{name: 'name', type: 'string'}]1202 });1203 var v2 = createType({1204 type: 'record',1205 name: 'Person',1206 fields: [1207 {name: 'age', type: 'int'},1208 {name: 'name', type: 'string'}1209 ]1210 });1211 assert.throws(function () { v2.createResolver(v1); });1212 });1213 test('resolve from recursive schema', function () {1214 var v1 = createType({1215 type: 'record',1216 name: 'Person',1217 fields: [{name: 'friends', type: {type: 'array', items: 'Person'}}]1218 });1219 var v2 = createType({1220 type: 'record',1221 name: 'Person',1222 fields: [{name: 'age', type: 'int', 'default': -1}]1223 });1224 var resolver = v2.createResolver(v1);1225 var p1 = {friends: [{friends: []}]};1226 var p2 = v2.fromBuffer(v1.toBuffer(p1), resolver);1227 assert.deepEqual(p2, {age: -1});1228 });1229 test('resolve to recursive schema', function () {1230 var v1 = createType({1231 type: 'record',1232 name: 'Person',1233 fields: [{name: 'age', type: 'int', 'default': -1}]1234 });1235 var v2 = createType({1236 type: 'record',1237 name: 'Person',1238 fields: [1239 {1240 name: 'friends',1241 type: {type: 'array', items: 'Person'},1242 'default': []1243 }1244 ]1245 });1246 var resolver = v2.createResolver(v1);1247 var p1 = {age: 25};1248 var p2 = v2.fromBuffer(v1.toBuffer(p1), resolver);1249 assert.deepEqual(p2, {friends: []});1250 });1251 test('resolve from both recursive schema', function () {1252 var v1 = createType({1253 type: 'record',1254 name: 'Person',1255 fields: [1256 {name: 'friends', type: {type: 'array', items: 'Person'}},1257 {name: 'age', type: 'int'}1258 ]1259 });1260 var v2 = createType({1261 type: 'record',1262 name: 'Person',1263 fields: [{name: 'friends', type: {type: 'array', items: 'Person'}}]1264 });1265 var resolver = v2.createResolver(v1);1266 var p1 = {friends: [{age: 1, friends: []}], age: 10};1267 var p2 = v2.fromBuffer(v1.toBuffer(p1), resolver);1268 assert.deepEqual(p2, {friends: [{friends: []}]});1269 });1270 test('resolve multiple matching aliases', function () {1271 var v1 = createType({1272 type: 'record',1273 name: 'Person',1274 fields: [1275 {name: 'phone', type: 'string'},1276 {name: 'number', type: 'string'}1277 ]1278 });1279 var v2 = createType({1280 type: 'record',1281 name: 'Person',1282 fields: [{name: 'number', type: 'string', aliases: ['phone']}]1283 });1284 assert.throws(function () { v2.createResolver(v1); });1285 });1286 test('getName', function () {1287 var t = createType({1288 type: 'record',1289 name: 'Person',1290 doc: 'Hi!',1291 namespace: 'earth',1292 aliases: ['Human'],1293 fields: [1294 {name: 'friends', type: {type: 'array', items: 'string'}},1295 {name: 'age', aliases: ['years'], type: {type: 'int'}}1296 ]1297 });1298 assert.strictEqual(t.getName(), 'earth.Person');1299 assert.equal(t.getName(true), 'record');1300 });1301 test('getSchema', function () {1302 var t = createType({1303 type: 'record',1304 name: 'Person',1305 doc: 'Hi!',1306 namespace: 'earth',1307 aliases: ['Human'],1308 fields: [1309 {name: 'friends', type: {type: 'array', items: 'string'}},1310 {name: 'age', aliases: ['years'], type: {type: 'int'}}1311 ]1312 });1313 assert.equal(1314 t.getSchema(),1315 '{"name":"earth.Person","type":"record","fields":[{"name":"friends","type":{"type":"array","items":"string"}},{"name":"age","type":"int"}]}'1316 );1317 assert.equal(t.getSchema(true), '"earth.Person"');1318 });1319 test('getSchema recursive schema', function () {1320 var t = createType({1321 type: 'record',1322 name: 'Person',1323 namespace: 'earth',1324 fields: [1325 {name: 'friends', type: {type: 'array', items: 'Person'}},1326 ]1327 });1328 assert.equal(1329 t.getSchema(),1330 '{"name":"earth.Person","type":"record","fields":[{"name":"friends","type":{"type":"array","items":"earth.Person"}}]}'1331 );1332 assert.equal(t.getSchema(true), '"earth.Person"');1333 });1334 test('toString record', function () {1335 var T = createType({1336 type: 'record',1337 name: 'Person',1338 fields: [{name: 'pwd', type: 'bytes'}]1339 }).getRecordConstructor();1340 var r = new T(new Buffer([1, 2]));1341 assert.equal(r.$toString(), T.getType().toString(r));1342 });1343 test('clone', function () {1344 var t = createType({1345 type: 'record',1346 name: 'Person',1347 fields: [{name: 'age', type: 'int'}, {name: 'name', type: 'string'}]1348 });1349 var Person = t.getRecordConstructor();1350 var o = {age: 25, name: 'Ann'};1351 var c = t.clone(o);1352 assert.deepEqual(c, o);1353 assert(c instanceof Person);1354 c.age = 26;1355 assert.equal(o.age, 25);1356 assert.strictEqual(c.$getType(), t);1357 assert.deepEqual(c.$clone(), c);1358 });1359 test('clone field hook', function () {1360 var t = createType({1361 type: 'record',1362 name: 'Person',1363 fields: [{name: 'age', type: 'int'}, {name: 'name', type: 'string'}]1364 });1365 var o = {name: 'Ann', age: 25};1366 var c = t.clone(o, {fieldHook: function (f, o, r) {1367 assert.strictEqual(r, t);1368 return f._type instanceof types.StringType ? o.toUpperCase() : o;1369 }});1370 assert.deepEqual(c, {name: 'ANN', age: 25});1371 });1372 test('get full name & aliases', function () {1373 var t = createType({1374 type: 'record',1375 name: 'Person',1376 namespace: 'a',1377 fields: [{name: 'age', type: 'int'}, {name: 'name', type: 'string'}]1378 });1379 assert.equal(t.getName(), 'a.Person');1380 assert.deepEqual(t.getAliases(), []);1381 });1382 test('field getters', function () {1383 var t = createType({1384 type: 'record',1385 name: 'Person',1386 namespace: 'a',1387 fields: [1388 {name: 'age', type: 'int'},1389 {name: 'name', type: 'string', aliases: ['word'], namespace: 'b'}1390 ]1391 });1392 var fields = t.getFields();1393 assert.deepEqual(fields[0].getAliases(), []);1394 assert.deepEqual(fields[1].getAliases(), ['word']);1395 assert.equal(fields[1].getName(), 'name'); // Namespaces are ignored.1396 assert.deepEqual(fields[1].getType(), createType('string'));1397 fields.push('null');1398 assert.equal(t.getFields().length, 2); // No change.1399 });1400 test('field order', function () {1401 var t = createType({1402 type: 'record',1403 name: 'Person',1404 fields: [{name: 'age', type: 'int'}]1405 });1406 var field = t.getFields()[0];1407 assert.equal(field.getOrder(), 'ascending'); // Default.1408 });1409 test('compare buffers default order', function () {1410 var t = createType({1411 type: 'record',1412 name: 'Person',1413 fields: [1414 {name: 'age', type: 'long'},1415 {name: 'name', type: 'string'},1416 {name: 'weight', type: 'float'},1417 ]1418 });1419 var b1 = t.toBuffer({age: 20, name: 'Ann', weight: 0.5});1420 assert.equal(t.compareBuffers(b1, b1), 0);1421 var b2 = t.toBuffer({age: 20, name: 'Bob', weight: 0});1422 assert.equal(t.compareBuffers(b1, b2), -1);1423 var b3 = t.toBuffer({age: 19, name: 'Carrie', weight: 0});1424 assert.equal(t.compareBuffers(b1, b3), 1);1425 });1426 test('compare buffers custom order', function () {1427 var t = createType({1428 type: 'record',1429 name: 'Person',1430 fields: [1431 {name: 'meta', type: {type: 'map', values: 'int'}, order: 'ignore'},1432 {name: 'name', type: 'string', order: 'descending'}1433 ]1434 });1435 var b1 = t.toBuffer({meta: {}, name: 'Ann'});1436 assert.equal(t.compareBuffers(b1, b1), 0);1437 var b2 = t.toBuffer({meta: {foo: 1}, name: 'Bob'});1438 assert.equal(t.compareBuffers(b1, b2), 1);1439 var b3 = t.toBuffer({meta: {foo: 0}, name: 'Alex'});1440 assert.equal(t.compareBuffers(b1, b3), -1);1441 });1442 test('compare buffers invalid order', function () {1443 assert.throws(function () { createType({1444 type: 'record',1445 name: 'Person',1446 fields: [{name: 'age', type: 'int', order: 'up'}]1447 }); });1448 });1449 test('error type', function () {1450 var t = createType({1451 type: 'error',1452 name: 'Ouch',1453 fields: [{name: 'name', type: 'string'}]1454 });1455 var E = t.getRecordConstructor();1456 var err = new E('MyError');1457 assert(err instanceof Error);1458 });1459 test('isValid hook', function () {1460 var t = createType({1461 type: 'record',1462 name: 'Person',1463 fields: [1464 {name: 'age', type: 'int'},1465 {name: 'names', type: {type: 'array', items: 'string'}}1466 ]1467 });1468 var hasErr = false;1469 try {1470 assert(!t.isValid({age: 23, names: ['ann', null]}, {errorHook: hook}));1471 } catch (err) {1472 hasErr = true;1473 }1474 assert(hasErr);1475 hasErr = false;1476 try {1477 // Again to make sure `PATH` was correctly reset.1478 assert(!t.isValid({age: 23, names: ['ann', null]}, {errorHook: hook}));1479 } catch (err) {1480 hasErr = true;1481 }1482 assert(hasErr);1483 function hook(path, obj, type) {1484 assert.strictEqual(type, t.getFields()[1].getType().getItemsType());1485 assert.deepEqual(path, ['names', '1']);1486 throw new Error();1487 }1488 });1489 test('isValid empty record', function () {1490 var t = createType({type: 'record', name: 'Person', fields: []});1491 assert(t.isValid({}));1492 });1493 });1494 suite('AbstractLongType', function () {1495 var fastLongType = new types.LongType();1496 suite('unpacked', function () {1497 var slowLongType = types.LongType.using({1498 fromBuffer: function (buf) {1499 var neg = buf[7] >> 7;1500 if (neg) { // Negative number.1501 invert(buf);1502 }1503 var n = buf.readInt32LE() + Math.pow(2, 32) * buf.readInt32LE(4);1504 if (neg) {1505 invert(buf);1506 n = -n - 1;1507 }1508 return n;1509 },1510 toBuffer: function (n) {1511 var buf = new Buffer(8);1512 var neg = n < 0;1513 if (neg) {1514 invert(buf);1515 n = -n - 1;1516 }1517 buf.writeInt32LE(n | 0);1518 var h = n / Math.pow(2, 32) | 0;1519 buf.writeInt32LE(h ? h : (n >= 0 ? 0 : -1), 4);1520 if (neg) {1521 invert(buf);1522 }1523 return buf;1524 },1525 isValid: function (n) {1526 return typeof n == 'number' && n % 1 === 0;1527 },1528 fromJSON: function (n) { return n; },1529 toJSON: function (n) { return n; },1530 compare: function (n1, n2) {1531 return n1 === n2 ? 0 : (n1 < n2 ? -1 : 1);1532 }1533 });1534 test('encode', function () {1535 [123, -1, 321414, 900719925474090].forEach(function (n) {1536 assert.deepEqual(slowLongType.toBuffer(n), fastLongType.toBuffer(n));1537 });1538 });1539 test('decode', function () {1540 [123, -1, 321414, 900719925474090].forEach(function (n) {1541 var buf = fastLongType.toBuffer(n);1542 assert.deepEqual(slowLongType.fromBuffer(buf), n);1543 });1544 });1545 test('clone', function () {1546 assert.equal(slowLongType.clone(123), 123);1547 assert.equal(slowLongType.fromString('-1'), -1);1548 assert.equal(slowLongType.toString(-1), '-1');1549 });1550 test('random', function () {1551 assert(slowLongType.isValid(slowLongType.random()));1552 });1553 test('isValid hook', function () {1554 var s = 'hi';1555 var errs = [];1556 assert(!slowLongType.isValid(s, {errorHook: hook}));1557 assert.deepEqual(errs, [s]);1558 assert.throws(function () { slowLongType.toBuffer(s); });1559 function hook(path, obj, type) {1560 assert.strictEqual(type, slowLongType);1561 assert.equal(path.length, 0);1562 errs.push(obj);1563 }1564 });1565 });1566 suite('packed', function () {1567 var slowLongType = types.LongType.using({1568 fromBuffer: function (buf) {1569 var tap = new Tap(buf);1570 return tap.readLong();1571 },1572 toBuffer: function (n) {1573 var buf = new Buffer(10);1574 var tap = new Tap(buf);1575 tap.writeLong(n);1576 return buf.slice(0, tap.pos);1577 },1578 fromJSON: function (n) { return n; },1579 toJSON: function (n) { return n; },1580 isValid: function (n) { return typeof n == 'number' && n % 1 === 0; },1581 compare: function (n1, n2) {1582 return n1 === n2 ? 0 : (n1 < n2 ? -1 : 1);1583 }1584 }, true);1585 test('encode', function () {1586 [123, -1, 321414, 900719925474090].forEach(function (n) {1587 assert.deepEqual(slowLongType.toBuffer(n), fastLongType.toBuffer(n));1588 });1589 });1590 test('decode', function () {1591 [123, -1, 321414, 900719925474090].forEach(function (n) {1592 var buf = fastLongType.toBuffer(n);1593 assert.deepEqual(slowLongType.fromBuffer(buf), n);1594 });1595 });1596 test('clone', function () {1597 assert.equal(slowLongType.clone(123), 123);1598 assert.equal(slowLongType.fromString('-1'), -1);1599 assert.equal(slowLongType.toString(-1), '-1');1600 });1601 test('random', function () {1602 assert(slowLongType.isValid(slowLongType.random()));1603 });1604 });1605 test('incomplete buffer', function () {1606 // Check that `fromBuffer` doesn't get called.1607 var slowLongType = new types.LongType.using({1608 fromBuffer: function () { throw new Error('no'); },1609 toBuffer: null,1610 fromJSON: null,1611 toJSON: null,1612 isValid: null,1613 compare: null1614 });1615 var buf = fastLongType.toBuffer(12314);1616 assert.deepEqual(1617 slowLongType.decode(buf.slice(0, 1)),1618 {value: undefined, offset: -1}1619 );1620 });1621 });1622 suite('LogicalType', function () {1623 function DateType(attrs, opts) {1624 types.LogicalType.call(this, attrs, opts, [types.LongType]);1625 }1626 util.inherits(DateType, types.LogicalType);1627 DateType.prototype._fromValue = function (val) { return new Date(val); };1628 DateType.prototype._toValue = function (date) { return +date; };1629 DateType.prototype._resolve = function (type) {1630 if (type instanceof types.StringType) {1631 return function (str) { return new Date(Date.parse(str)); };1632 } else if (type instanceof types.LongType) {1633 return this.fromValue;1634 }1635 };1636 function AgeType(attrs, opts) {1637 types.LogicalType.call(this, attrs, opts, [types.IntType]);1638 }1639 util.inherits(AgeType, types.LogicalType);1640 AgeType.prototype._fromValue = function (val) {1641 if (val < 0) { throw new Error('invalid age'); }1642 return val;1643 };1644 AgeType.prototype._toValue = AgeType.prototype._fromValue;1645 var logicalTypes = {age: AgeType, date: DateType};1646 test('valid type', function () {1647 var t = createType({1648 type: 'long',1649 logicalType: 'date'1650 }, {logicalTypes: logicalTypes});1651 assert(t instanceof DateType);1652 assert(t.getUnderlyingType() instanceof types.LongType);1653 assert(t.isValid(t.random()));1654 var d = new Date(123);1655 assert.equal(t.toString(d), '123');1656 assert.deepEqual(t.fromString('123'), d);1657 assert.deepEqual(t.clone(d), d);1658 assert.equal(t.compare(d, d), 0);1659 assert.equal(t.getSchema(), '"long"');1660 });1661 test('invalid type', function () {1662 var attrs = {1663 type: 'int',1664 logicalType: 'date'1665 };1666 var t;1667 t = createType(attrs); // Missing.1668 assert(t instanceof types.IntType);1669 t = createType(attrs, {logicalTypes: logicalTypes}); // Invalid.1670 assert(t instanceof types.IntType);1671 assert.throws(function () {1672 createType(attrs, {1673 logicalTypes: logicalTypes,1674 assertLogicalTypes: true1675 });1676 });1677 });1678 test('nested types', function () {1679 var attrs = {1680 name: 'Person',1681 type: 'record',1682 fields: [1683 {name: 'age', type: {type: 'int', logicalType: 'age'}},1684 {name: 'time', type: {type: 'long', logicalType: 'date'}}1685 ]1686 };1687 var base = createType(attrs);1688 var derived = createType(attrs, {logicalTypes: logicalTypes});1689 var fields = derived.getFields();1690 assert(fields[0].getType() instanceof AgeType);1691 assert(fields[1].getType() instanceof DateType);1692 var date = new Date(Date.now());1693 var buf = base.toBuffer({age: 12, time: +date});1694 var person = derived.fromBuffer(buf);1695 assert.deepEqual(person.age, 12);1696 assert.deepEqual(person.time, date);1697 assert.throws(function () { derived.toBuffer({age: -1, date: date}); });1698 var invalid = {age: -1, time: date};1699 assert.throws(function () { derived.toBuffer(invalid); });1700 var hasError = false;1701 derived.isValid(invalid, {errorHook: function (path, any, type) {1702 hasError = true;1703 assert.deepEqual(path, ['age']);1704 assert.equal(any, -1);1705 assert(type instanceof AgeType);1706 }});1707 assert(hasError);1708 });1709 test('recursive', function () {1710 function Person(friends) { this.friends = friends || []; }1711 function PersonType(attrs, opts) {1712 types.LogicalType.call(this, attrs, opts);1713 }1714 util.inherits(PersonType, types.LogicalType);1715 PersonType.prototype._fromValue = function (val) {1716 return new Person(val.friends);1717 };1718 PersonType.prototype._toValue = function (val) { return val; };1719 var t = createType({1720 type: 'record',1721 name: 'Person',1722 namespace: 'earth',1723 logicalType: 'person',1724 fields: [1725 {name: 'friends', type: {type: 'array', items: 'Person'}},1726 ]1727 }, {logicalTypes: {'person': PersonType}});1728 var p1 = new Person([new Person()]);1729 var buf = t.toBuffer(p1);1730 var p2 = t.fromBuffer(buf);1731 assert(p2 instanceof Person);1732 assert(p2.friends[0] instanceof Person);1733 assert.deepEqual(p2, p1);1734 });1735 test('resolve underlying > logical', function () {1736 var t1 = createType({type: 'string'});1737 var t2 = createType({1738 type: 'long',1739 logicalType: 'date'1740 }, {logicalTypes: logicalTypes});1741 var d1 = new Date(Date.now());1742 var buf = t1.toBuffer('' + d1);1743 var res = t2.createResolver(t1);1744 assert.throws(function () { t2.createResolver(createType('float')); });1745 var d2 = t2.fromBuffer(buf, res);1746 assert.deepEqual('' + d2, '' + d1); // Rounding error on date objects.1747 });1748 test('resolve logical > underlying', function () {1749 var t1 = createType({1750 type: 'long',1751 logicalType: 'date'1752 }, {logicalTypes: logicalTypes});1753 var t2 = createType({type: 'double'}); // Note long > double too.1754 var d = new Date(Date.now());1755 var buf = t1.toBuffer(d);1756 var res = t2.createResolver(t1);1757 assert.throws(function () { createType('int').createResolver(t1); });1758 assert.equal(t2.fromBuffer(buf, res), +d);1759 });1760 suite('union logical types', function () {1761 // Unions are slightly tricky to override with logical types since their1762 // schemas aren't represented as objects.1763 var schema = [1764 'null',1765 {1766 name: 'Person',1767 type: 'record',1768 fields: [1769 {name: 'name', type: 'string'},1770 {name: 'age', type: ['null', 'int'], 'default': null}1771 ]1772 }1773 ];1774 function createUnionTypeHook(Type) {1775 var visited = [];1776 return function(attrs, opts) {1777 if (attrs instanceof Array && !~visited.indexOf(attrs)) {1778 visited.push(attrs);1779 return new Type(attrs, opts);1780 }1781 };1782 }1783 test('unwrapped', function () {1784 /**1785 * A generic union type which exposes its values directly.1786 *1787 * This implementation is pretty minimal, we could optimize it by caching1788 * the underlying union's type names for example.1789 *1790 */1791 function UnwrappedUnionType(attrs, opts) {1792 types.LogicalType.call(this, attrs, opts);1793 }1794 util.inherits(UnwrappedUnionType, types.LogicalType);1795 UnwrappedUnionType.prototype._fromValue = function (val) {1796 return val === null ? null : val[Object.keys(val)[0]];1797 };1798 UnwrappedUnionType.prototype._toValue = function (any) {1799 return this.getUnderlyingType().clone(any, {wrapUnions: true});1800 };1801 var t1 = createType(1802 schema,1803 {typeHook: createUnionTypeHook(UnwrappedUnionType)}1804 );1805 var obj = {name: 'Ann', age: 23};1806 assert(t1.isValid(obj));1807 var buf = t1.toBuffer(obj);1808 var t2 = createType(schema);1809 assert.deepEqual(1810 t2.fromBuffer(buf),1811 {Person: {name: 'Ann', age: {'int': 23}}}1812 );1813 });1814 test('optional', function () {1815 /**1816 * A basic optional type.1817 *1818 * It assumes an underlying union of the form `["null", ???]`.1819 *1820 * Enhancements include:1821 *1822 * + Performing a check in the constructor on the underlying type (i.e.1823 * union with the correct form).1824 * + Code-generating the conversion methods (especially a constructor1825 * for `_toValue`).1826 *1827 */1828 function OptionalType(attrs, opts) {1829 types.LogicalType.call(this, attrs, opts);1830 var type = this.getUnderlyingType().getTypes()[1];1831 this._name = type.getName() || type.getName(true);1832 }1833 util.inherits(OptionalType, types.LogicalType);1834 OptionalType.prototype._fromValue = function (val) {1835 return val === null ? null : val[this._name];1836 };1837 OptionalType.prototype._toValue = function (any) {1838 if (any === null) {1839 return null;1840 }1841 var obj = {};1842 obj[this._name] = any;1843 return obj;1844 };1845 var t1 = createType(1846 schema,1847 {typeHook: createUnionTypeHook(OptionalType)}1848 );1849 var obj = {name: 'Ann', age: 23};1850 assert(t1.isValid(obj));1851 var buf = t1.toBuffer(obj);1852 var t2 = createType(schema);1853 assert.deepEqual(1854 t2.fromBuffer(buf),1855 {Person: {name: 'Ann', age: {'int': 23}}}1856 );1857 });1858 });1859 test('even integer', function () {1860 function EvenIntType(attrs, opts) {1861 types.LogicalType.call(this, attrs, opts, [types.IntType]);1862 }1863 util.inherits(EvenIntType, types.LogicalType);1864 EvenIntType.prototype._fromValue = function (val) {1865 this._assertValid(val);1866 return val;1867 };1868 EvenIntType.prototype._toValue = EvenIntType.prototype._fromValue;1869 EvenIntType.prototype._assertValid = function (any) {1870 if (any !== (any | 0) || any % 2) {1871 throw new Error('invalid');1872 }1873 };1874 var opts = {logicalTypes: {'even-integer': EvenIntType}};1875 var t = createType({type: 'int', logicalType: 'even-integer'}, opts);1876 assert(t.isValid(2));1877 assert(!t.isValid(3));1878 assert(!t.isValid('abc'));1879 assert.equal(t.fromBuffer(new Buffer([4])), 2);1880 assert.equal(t.clone(4), 4);1881 assert.equal(t.fromString('6'), 6);1882 assert.throws(function () { t.clone(3); });1883 assert.throws(function () { t.fromString('5'); });1884 assert.throws(function () { t.toBuffer(3); });1885 assert.throws(function () { t.fromBuffer(new Buffer([2])); });1886 });1887 });1888 suite('createType', function () {1889 test('null type', function () {1890 assert.throws(function () { createType(null); });1891 });1892 test('unknown types', function () {1893 assert.throws(function () { createType('a'); });1894 assert.throws(function () { createType({type: 'b'}); });1895 });1896 test('namespaced type', function () {1897 var type = createType({1898 type: 'record',1899 name: 'Human',1900 namespace: 'earth',1901 fields: [1902 {1903 name: 'id',1904 type: {type: 'fixed', name: 'Id', size: 2, namespace: 'all'}1905 },1906 {1907 name: 'alien',1908 type: {1909 type: 'record',1910 name: 'Alien',1911 namespace: 'all',1912 fields: [1913 {name: 'friend', type: 'earth.Human'},1914 {name: 'id', type: 'Id'},1915 ]1916 }1917 }1918 ]1919 });1920 assert.equal(type._name, 'earth.Human');1921 assert.equal(type._fields[0]._type._name, 'all.Id');1922 assert.equal(type._fields[1]._type._name, 'all.Alien');1923 });1924 test('wrapped primitive', function () {1925 var type = createType({1926 type: 'record',1927 name: 'Person',1928 fields: [{name: 'nothing', type: {type: 'null'}}]1929 });1930 assert.strictEqual(type._fields[0]._type.constructor, types.NullType);1931 });1932 test('fromBuffer truncated', function () {1933 var type = createType('int');1934 assert.throws(function () {1935 type.fromBuffer(new Buffer([128]));1936 });1937 });1938 test('fromBuffer bad resolver', function () {1939 var type = createType('int');1940 assert.throws(function () {1941 type.fromBuffer(new Buffer([0]), 123, {});1942 });1943 });1944 test('fromBuffer trailing', function () {1945 var type = createType('int');1946 assert.throws(function () {1947 type.fromBuffer(new Buffer([0, 2]));1948 });1949 });1950 test('fromBuffer trailing with resolver', function () {1951 var type = createType('int');1952 var resolver = type.createResolver(createType(['int']));1953 assert.equal(type.fromBuffer(new Buffer([0, 2]), resolver), 1);1954 });1955 test('toBuffer', function () {1956 var type = createType('int');1957 assert.throws(function () { type.toBuffer('abc'); });1958 assert.doesNotThrow(function () { type.toBuffer(123); });1959 });1960 test('toBuffer and resize', function () {1961 var type = createType('string');1962 assert.deepEqual(type.toBuffer('\x01', 1), new Buffer([2, 1]));1963 });1964 test('type hook', function () {1965 var refs = [];1966 var ts = [];1967 var o = {1968 type: 'record',1969 name: 'Human',1970 fields: [1971 {name: 'age', type: 'int'},1972 {name: 'name', type: {type: 'string'}}1973 ]1974 };1975 createType(o, {typeHook: hook});1976 assert.equal(ts.length, 1);1977 assert.equal(ts[0].getName(), 'Human');1978 function hook(schema, opts) {1979 if (~refs.indexOf(schema)) {1980 // Already seen this schema.1981 return;1982 }1983 refs.push(schema);1984 var type = createType(schema, opts);1985 if (type instanceof types.RecordType) {1986 ts.push(type);1987 }1988 return type;1989 }1990 });1991 test('type hook invalid return value', function () {1992 assert.throws(function () {1993 createType({type: 'int'}, {typeHook: hook});1994 });1995 function hook() { return 'int'; }1996 });1997 test('fingerprint', function () {1998 var t = createType('int');1999 var buf = new Buffer('ef524ea1b91e73173d938ade36c1db32', 'hex');2000 assert.deepEqual(t.getFingerprint('md5'), buf);2001 assert.deepEqual(t.getFingerprint(), buf);2002 });2003 test('getSchema default', function () {2004 var type = createType({2005 type: 'record',2006 name: 'Human',2007 fields: [2008 {name: 'id1', type: ['string', 'null'], 'default': ''},2009 {name: 'id2', type: ['null', 'string'], 'default': null}2010 ]2011 });2012 assert.deepEqual(2013 JSON.parse(type.getSchema()),2014 {2015 type: 'record',2016 name: 'Human',2017 fields: [2018 {name: 'id1', type: ['string', 'null']}, // Stripped defaults.2019 {name: 'id2', type: ['null', 'string']}2020 ]2021 }2022 );2023 });2024 });2025 suite('fromString', function () {2026 test('int', function () {2027 var t = createType('int');2028 assert.equal(t.fromString('2'), 2);2029 assert.throws(function () { t.fromString('"a"'); });2030 });2031 test('string', function () {2032 var t = createType('string');2033 assert.equal(t.fromString('"2"'), '2');2034 assert.throws(function () { t.fromString('a'); });2035 });2036 test('coerce buffers', function () {2037 var t = createType({2038 name: 'Ids',2039 type: 'record',2040 fields: [{name: 'id1', type: {name: 'Id1', type: 'fixed', size: 2}}]2041 });2042 var o = {id1: new Buffer([0, 1])};2043 var s = '{"id1": "\\u0000\\u0001"}';2044 var c = t.fromString(s);2045 assert.deepEqual(c, o);2046 assert(c instanceof t.getRecordConstructor());2047 });2048 });2049 suite('toString', function () {2050 test('int', function () {2051 var t = createType('int');2052 assert.equal(t.toString(2), '2');2053 assert.throws(function () { t.toString('a'); });2054 });2055 });2056 suite('resolve', function () {2057 test('non type', function () {2058 var t = createType({type: 'map', values: 'int'});2059 var obj = {type: 'map', values: 'int'};2060 assert.throws(function () { t.createResolver(obj); });2061 });2062 test('union to valid union', function () {2063 var t1 = createType(['int', 'string']);2064 var t2 = createType(['null', 'string', 'long']);2065 var resolver = t2.createResolver(t1);2066 var buf = t1.toBuffer({'int': 12});2067 assert.deepEqual(t2.fromBuffer(buf, resolver), {'long': 12});2068 });2069 test('union to invalid union', function () {2070 var t1 = createType(['int', 'string']);2071 var t2 = createType(['null', 'long']);2072 assert.throws(function () { t2.createResolver(t1); });2073 });2074 test('union to non union', function () {2075 var t1 = createType(['int', 'long']);2076 var t2 = createType('long');2077 var resolver = t2.createResolver(t1);2078 var buf = t1.toBuffer({'int': 12});2079 assert.equal(t2.fromBuffer(buf, resolver), 12);2080 buf = new Buffer([4, 0]);2081 assert.throws(function () { t2.fromBuffer(buf, resolver); });2082 });2083 test('union to invalid non union', function () {2084 var t1 = createType(['int', 'long']);2085 var t2 = createType('int');2086 assert.throws(function() { t2.createResolver(t1); });2087 });2088 });2089 suite('type references', function () {2090 test('existing', function () {2091 var type = createType({2092 type: 'record',2093 name: 'Person',2094 fields: [{name: 'so', type: 'Person'}]2095 });2096 assert.strictEqual(type, type._fields[0]._type);2097 });2098 test('namespaced', function () {2099 var type = createType({2100 type: 'record',2101 name: 'Person',2102 fields: [2103 {2104 name: 'so',2105 type: {2106 type: 'record',2107 name: 'Person',2108 fields: [{name: 'age', type: 'int'}],2109 namespace: 'a'2110 }2111 }2112 ]2113 });2114 assert.equal(type._name, 'Person');2115 assert.equal(type._fields[0]._type._name, 'a.Person');2116 });2117 test('redefining', function () {2118 assert.throws(function () {2119 createType({2120 type: 'record',2121 name: 'Person',2122 fields: [2123 {2124 name: 'so',2125 type: {2126 type: 'record',2127 name: 'Person',2128 fields: [{name: 'age', type: 'int'}]2129 }2130 }2131 ]2132 });2133 });2134 });2135 test('missing', function () {2136 assert.throws(function () {2137 createType({2138 type: 'record',2139 name: 'Person',2140 fields: [{name: 'so', type: 'Friend'}]2141 });2142 });2143 });2144 test('redefining primitive', function () {2145 assert.throws( // Unqualified.2146 function () { createType({type: 'fixed', name: 'int', size: 2}); }2147 );2148 assert.throws( // Qualified.2149 function () {2150 createType({type: 'fixed', name: 'int', size: 2, namespace: 'a'});2151 }2152 );2153 });2154 test('aliases', function () {2155 var type = createType({2156 type: 'record',2157 name: 'Person',2158 namespace: 'a',2159 aliases: ['Human', 'b.Being'],2160 fields: [{name: 'age', type: 'int'}]2161 });2162 assert.deepEqual(type._aliases, ['a.Human', 'b.Being']);2163 });2164 test('invalid', function () {2165 // Name.2166 assert.throws(function () {2167 createType({type: 'fixed', name: 'ID$', size: 3});2168 });2169 // Namespace.2170 assert.throws(function () {2171 createType({type: 'fixed', name: 'ID', size: 3, namespace: '1a'});2172 });2173 // Qualified.2174 assert.throws(function () {2175 createType({type: 'fixed', name: 'a.2.ID', size: 3});2176 });2177 });2178 });2179 suite('decode', function () {2180 test('long valid', function () {2181 var t = createType('long');2182 var buf = new Buffer([0, 128, 2, 0]);2183 var res = t.decode(buf, 1);2184 assert.deepEqual(res, {value: 128, offset: 3});2185 });2186 test('bytes invalid', function () {2187 var t = createType('bytes');2188 var buf = new Buffer([4, 1]);2189 var res = t.decode(buf, 0);2190 assert.deepEqual(res, {value: undefined, offset: -1});2191 });2192 });2193 suite('encode', function () {2194 test('int valid', function () {2195 var t = createType('int');2196 var buf = new Buffer(2);2197 buf.fill(0);2198 var n = t.encode(5, buf, 1);2199 assert.equal(n, 2);2200 assert.deepEqual(buf, new Buffer([0, 10]));2201 });2202 test('string invalid', function () {2203 var t = createType('string');2204 var buf = new Buffer(1);2205 var n = t.encode('\x01\x02', buf, 0);2206 assert.equal(n, -2);2207 });2208 test('invalid', function () {2209 var t = createType('float');2210 var buf = new Buffer(2);2211 assert.throws(function () { t.encode('hi', buf, 0); });2212 });2213 });2214 suite('inspect', function () {2215 test('type', function () {2216 assert.equal(createType('int').inspect(), '<IntType>');2217 assert.equal(2218 createType({type: 'map', values: 'string'}).inspect(),2219 '<MapType {"values":"string"}>'2220 );2221 assert.equal(2222 createType({type: 'fixed', name: 'Id', size: 2}).inspect(),2223 '<FixedType "Id">'2224 );2225 });2226 test('field', function () {2227 var type = createType({2228 type: 'record',2229 name: 'Person',2230 fields: [{name: 'age', type: 'int'}]2231 });2232 var field = type.getFields()[0];2233 assert.equal(field.inspect(), '<Field "age">');2234 });2235 test('resolver', function () {2236 var t1 = createType('int');2237 var t2 = createType('double');2238 var resolver = t2.createResolver(t1);2239 assert.equal(resolver.inspect(), '<Resolver>');2240 });2241 });2242 test('reset', function () {2243 types.Type.__reset(0);2244 var t = createType('string');2245 var buf = t.toBuffer('\x01');2246 assert.deepEqual(buf, new Buffer([2, 1]));2247 });2248});2249function testType(Type, data, invalidSchemas) {2250 data.forEach(function (elem) {2251 test('roundtrip', function () {2252 var type = new Type(elem.schema);2253 elem.valid.forEach(function (v) {2254 assert(type.isValid(v), '' + v);2255 var fn = elem.check || assert.deepEqual;2256 fn(type.fromBuffer(type.toBuffer(v)), v);2257 fn(type.fromString(type.toString(v), {coerceBuffers: true}), v);2258 });2259 elem.invalid.forEach(function (v) {2260 assert(!type.isValid(v), '' + v);2261 assert.throws(function () { type.isValid(v, {errorHook: hook}); });2262 assert.throws(function () { type.toBuffer(v); });2263 function hook() { throw new Error(); }2264 });2265 var n = 50;2266 while (n--) {2267 // Run a few times to make sure we cover any branches.2268 assert(type.isValid(type.random()));2269 }2270 });2271 });2272 test('skip', function () {2273 data.forEach(function (elem) {2274 var fn = elem.check || assert.deepEqual;2275 var items = elem.valid;2276 if (items.length > 1) {2277 var type = new Type(elem.schema);2278 var buf = new Buffer(1024);2279 var tap = new Tap(buf);2280 type._write(tap, items[0]);2281 type._write(tap, items[1]);2282 tap.pos = 0;2283 type._skip(tap);2284 fn(type._read(tap), items[1]);2285 }2286 });2287 });2288 if (invalidSchemas) {2289 test('invalid', function () {2290 invalidSchemas.forEach(function (schema) {2291 assert.throws(function () { new Type(schema); });2292 });2293 });2294 }2295}2296function getResolver(reader, writer) {2297 return createType(reader).createResolver(createType(writer));2298}2299function floatEquals(a, b) {2300 return Math.abs((a - b) / Math.min(a, b)) < 1e-7;2301}2302function invert(buf) {2303 var len = buf.length;2304 while (len--) {2305 buf[len] = ~buf[len];2306 }...

saved_objects_type_registry.test.ts

Source:saved_objects_type_registry.test.ts

...31 beforeEach(() => {32 registry = new SavedObjectTypeRegistry();33 });34 it('allows to register types', () => {35 registry.registerType(createType({ name: 'typeA' }));36 registry.registerType(createType({ name: 'typeB' }));37 registry.registerType(createType({ name: 'typeC' }));38 expect(39 registry40 .getAllTypes()41 .map((type) => type.name)42 .sort()43 ).toEqual(['typeA', 'typeB', 'typeC']);44 });45 it('throws when trying to register the same type twice', () => {46 registry.registerType(createType({ name: 'typeA' }));47 registry.registerType(createType({ name: 'typeB' }));48 expect(() => {49 registry.registerType(createType({ name: 'typeA' }));50 }).toThrowErrorMatchingInlineSnapshot(`"Type 'typeA' is already registered"`);51 });52 describe('#getType', () => {53 it(`retrieve a type by it's name`, () => {54 const typeA = createType({ name: 'typeA' });55 const typeB = createType({ name: 'typeB' });56 registry.registerType(typeA);57 registry.registerType(typeB);58 registry.registerType(createType({ name: 'typeC' }));59 expect(registry.getType('typeA')).toEqual(typeA);60 expect(registry.getType('typeB')).toEqual(typeB);61 expect(registry.getType('unknownType')).toBeUndefined();62 });63 it('forbids to mutate the registered types', () => {64 registry.registerType(65 createType({66 name: 'typeA',67 mappings: {68 properties: {69 someField: { type: 'text' },70 },71 },72 })73 );74 const typeA = registry.getType('typeA')!;75 expect(() => {76 typeA.migrations = {};77 }).toThrow();78 expect(() => {79 typeA.name = 'foo';80 }).toThrow();81 expect(() => {82 typeA.mappings.properties = {};83 }).toThrow();84 expect(() => {85 typeA.indexPattern = '.overrided';86 }).toThrow();87 });88 });89 describe('#getAllTypes', () => {90 it('returns all registered types', () => {91 const typeA = createType({ name: 'typeA' });92 const typeB = createType({ name: 'typeB' });93 const typeC = createType({ name: 'typeC' });94 registry.registerType(typeA);95 registry.registerType(typeB);96 const registered = registry.getAllTypes();97 expect(registered.length).toEqual(2);98 expect(registered).toContainEqual(typeA);99 expect(registered).toContainEqual(typeB);100 expect(registered).not.toContainEqual(typeC);101 });102 it('forbids to mutate the registered types', () => {103 registry.registerType(104 createType({105 name: 'typeA',106 mappings: {107 properties: {108 someField: { type: 'text' },109 },110 },111 })112 );113 registry.registerType(114 createType({115 name: 'typeB',116 migrations: {117 '1.0.0': jest.fn(),118 },119 })120 );121 const typeA = registry.getType('typeA')!;122 const typeB = registry.getType('typeB')!;123 expect(() => {124 typeA.migrations = {};125 }).toThrow();126 expect(() => {127 typeA.name = 'foo';128 }).toThrow();129 expect(() => {130 typeB.mappings.properties = {};131 }).toThrow();132 expect(() => {133 typeB.indexPattern = '.overrided';134 }).toThrow();135 });136 it('does not mutate the registered types when altering the list', () => {137 registry.registerType(createType({ name: 'typeA' }));138 registry.registerType(createType({ name: 'typeB' }));139 registry.registerType(createType({ name: 'typeC' }));140 const types = registry.getAllTypes();141 types.splice(0, 3);142 expect(registry.getAllTypes().length).toEqual(3);143 });144 });145 describe('#isNamespaceAgnostic', () => {146 const expectResult = (expected: boolean, schemaDefinition?: Partial<SavedObjectsType>) => {147 registry = new SavedObjectTypeRegistry();148 registry.registerType(createType({ name: 'foo', ...schemaDefinition }));149 expect(registry.isNamespaceAgnostic('foo')).toBe(expected);150 };151 it(`returns false when the type is not registered`, () => {152 expect(registry.isNamespaceAgnostic('unknownType')).toEqual(false);153 });154 it(`returns true for namespaceType 'agnostic'`, () => {155 expectResult(true, { namespaceType: 'agnostic' });156 });157 it(`returns false for other namespaceType`, () => {158 expectResult(false, { namespaceType: 'multiple' });159 expectResult(false, { namespaceType: 'single' });160 expectResult(false, { namespaceType: undefined });161 });162 });163 describe('#isSingleNamespace', () => {164 const expectResult = (expected: boolean, schemaDefinition?: Partial<SavedObjectsType>) => {165 registry = new SavedObjectTypeRegistry();166 registry.registerType(createType({ name: 'foo', ...schemaDefinition }));167 expect(registry.isSingleNamespace('foo')).toBe(expected);168 };169 it(`returns true when the type is not registered`, () => {170 expect(registry.isSingleNamespace('unknownType')).toEqual(true);171 });172 it(`returns true for namespaceType 'single'`, () => {173 expectResult(true, { namespaceType: 'single' });174 expectResult(true, { namespaceType: undefined });175 });176 it(`returns false for other namespaceType`, () => {177 expectResult(false, { namespaceType: 'agnostic' });178 expectResult(false, { namespaceType: 'multiple' });179 });180 });181 describe('#isMultiNamespace', () => {182 const expectResult = (expected: boolean, schemaDefinition?: Partial<SavedObjectsType>) => {183 registry = new SavedObjectTypeRegistry();184 registry.registerType(createType({ name: 'foo', ...schemaDefinition }));185 expect(registry.isMultiNamespace('foo')).toBe(expected);186 };187 it(`returns false when the type is not registered`, () => {188 expect(registry.isMultiNamespace('unknownType')).toEqual(false);189 });190 it(`returns true for namespaceType 'multiple'`, () => {191 expectResult(true, { namespaceType: 'multiple' });192 });193 it(`returns false for other namespaceType`, () => {194 expectResult(false, { namespaceType: 'agnostic' });195 expectResult(false, { namespaceType: 'single' });196 expectResult(false, { namespaceType: undefined });197 });198 });199 describe('#isHidden', () => {200 it('returns correct value for the type', () => {201 registry.registerType(createType({ name: 'typeA', hidden: true }));202 registry.registerType(createType({ name: 'typeB', hidden: false }));203 expect(registry.isHidden('typeA')).toEqual(true);204 expect(registry.isHidden('typeB')).toEqual(false);205 });206 it('returns false when the type is not registered', () => {207 registry.registerType(createType({ name: 'typeA', hidden: true }));208 registry.registerType(createType({ name: 'typeB', hidden: false }));209 expect(registry.isHidden('unknownType')).toEqual(false);210 });211 });212 describe('#getIndex', () => {213 it('returns correct value for the type', () => {214 registry.registerType(createType({ name: 'typeA', indexPattern: '.custom-index' }));215 registry.registerType(createType({ name: 'typeB', indexPattern: '.another-index' }));216 registry.registerType(createType({ name: 'typeWithNoIndex' }));217 expect(registry.getIndex('typeA')).toEqual('.custom-index');218 expect(registry.getIndex('typeB')).toEqual('.another-index');219 expect(registry.getIndex('typeWithNoIndex')).toBeUndefined();220 });221 it('returns undefined when the type is not registered', () => {222 registry.registerType(createType({ name: 'typeA', namespaceType: 'agnostic' }));223 registry.registerType(createType({ name: 'typeB', namespaceType: 'single' }));224 expect(registry.getIndex('unknownType')).toBeUndefined();225 });226 });227 describe('#isImportableAndExportable', () => {228 it('returns correct value for the type', () => {229 registry.registerType(230 createType({ name: 'typeA', management: { importableAndExportable: true } })231 );232 registry.registerType(233 createType({ name: 'typeB', management: { importableAndExportable: false } })234 );235 expect(registry.isImportableAndExportable('typeA')).toBe(true);236 expect(registry.isImportableAndExportable('typeB')).toBe(false);237 });238 it('returns false when the type is not registered', () => {239 registry.registerType(createType({ name: 'typeA', management: {} }));240 registry.registerType(createType({ name: 'typeB', management: {} }));241 expect(registry.isImportableAndExportable('typeA')).toBe(false);242 });243 it('returns false when management is not defined for the type', () => {244 registry.registerType(createType({ name: 'typeA' }));245 expect(registry.isImportableAndExportable('unknownType')).toBe(false);246 });247 });248 describe('#getImportableAndExportableTypes', () => {249 it('returns all registered types that are importable/exportable', () => {250 const typeA = createType({ name: 'typeA', management: { importableAndExportable: true } });251 const typeB = createType({ name: 'typeB' });252 const typeC = createType({ name: 'typeC', management: { importableAndExportable: false } });253 const typeD = createType({ name: 'typeD', management: { importableAndExportable: true } });254 registry.registerType(typeA);255 registry.registerType(typeB);256 registry.registerType(typeC);257 registry.registerType(typeD);258 const types = registry.getImportableAndExportableTypes();259 expect(types.length).toEqual(2);260 expect(types.map((t) => t.name)).toEqual(['typeA', 'typeD']);261 });262 });...

sendXcm.js

Source:sendXcm.js

...7 api, fromLocation='PHA30', toParaId=100, amount=100,8 toAddr='45R2pfjQUW2s9PQRHU48HQKLKHVMaDja7N3wpBtmF28UYDs2'9) {10 const bnAmount = bn1e12.muln(amount);11 return api.createType('Xcm', {12 WithdrawAsset: api.createType('WithdrawAsset', {13 assets: [14 api.createType('MultiAsset', {15 ConcreteFungible: api.createType('ConcreteFungible', {16 id: api.createType('MultiLocation', {17 X1: api.createType('Junction', {18 'GeneralKey': fromLocation19 })20 }),21 amount: api.createType('Compact<U128>', bnAmount),22 })23 }),24 ],25 effects: [26 api.createType('Order', {27 DepositReserveAsset: api.createType('DepositReserveAsset', {28 assets: [api.createType('MultiAsset', 'All')],29 dest: api.createType('MultiLocation', {30 X2: [31 api.createType('Junction', 'Parent'),32 api.createType('Junction', {33 Parachain: api.createType('Compact<U32>', toParaId),34 }),35 ]36 }),37 effects: [38 api.createType('Order', {39 DepositAsset: api.createType('DepositAsset', {40 assets: [41 api.createType('MultiAsset', 'All'),42 ],43 dest: api.createType('MultiLocation', {44 X1: api.createType('Junction', {45 AccountId32: api.createType('AccountId32Junction', {46 network: api.createType('NetworkId', 'Any'),47 id: toAddr,48 })49 })50 })51 })52 }),53 ]54 })55 })56 ],57 })58 });59}60async function main () {...

Using AI Code Generation

1import React from 'react';2import { createType } from 'storybook-root-elements';3import { storiesOf } from '@storybook/react';4import { withInfo } from '@storybook/addon-info';5import { withKnobs, text, boolean } from '@storybook/addon-knobs/react';6import { Button } from '../src/components/Button';7const stories = storiesOf('Button', module);8stories.addDecorator(withKnobs);9stories.add(10 withInfo()(() => {11 const label = text('Label', 'Click me');12 const disabled = boolean('Disabled', false);13 const type = createType('button', {14 onClick: () => alert('clicked'),15 });16 return <Button type={type} />;17 }),18);

Using AI Code Generation

1import { createType } from "storybook-root";2import { storiesOf } from "@storybook/react";3import React from "react";4import { withInfo } from "@storybook/addon-info";5import { withKnobs, text, boolean, number } from "@storybook/addon-knobs";6import { action } from "@storybook/addon-actions";7const stories = storiesOf("Test", module);8stories.addDecorator(withInfo).addDecorator(withKnobs);9stories.add("Test", () => {10 const name = text("name", "David");11 const age = number("age", 21);12 const isMale = boolean("isMale", true);13 const onClick = action("onClick");14 return (15 name: {name}, age: {age}, isMale: {isMale ? "true" : "false"}16 <button onClick={onClick}>Click Me!</button>17 );18});19stories.add("Test2", () => {20 const name = text("name", "David");21 const age = number("age", 21);22 const isMale = boolean("isMale", true);23 const onClick = action("onClick");24 return (25 name: {name}, age: {age}, isMale: {isMale ? "true" : "false"}26 <button onClick={onClick}>Click Me!</button>27 );28});29import { storiesOf } from "@storybook/react";30import React from "react";31import { withInfo } from "@storybook/addon-info";32import { withKnobs, text, boolean, number } from "@storybook/addon-knobs";33import { action } from "@storybook/addon-actions";34export const createType = (type) => {35 const stories = storiesOf(type, module);36 stories.addDecorator(withInfo).addDecorator(withKnobs);37 return stories;38};39import { configure } from "@storybook/react";40import { setOptions } from "@storybook/addon-options";41import { setDefaults } from "@storybook/addon-info";42setOptions({

Using AI Code Generation

1import { createType } from 'storybook-root';2const type = createType('test');3export default type;4import React from 'react';5import { storiesOf } from '@storybook/react';6import { action } from '@storybook/addon-actions';7import { boolean, withKnobs } from '@storybook/addon-knobs';8import type from './test';9storiesOf('Test', module)10 .addDecorator(withKnobs)11 .add('Test', () => (12 ));13import React from 'react';14import { storiesOf } from '@storybook/react';15import { action } from '@storybook/addon-actions';16import { boolean, withKnobs } from '@storybook/addon-knobs';17import type from './test';18storiesOf(type, module)19 .addDecorator(withKnobs)20 .add('Test', () => (21 ));22import { configure, addDecorator } from '@storybook/react';23import { withKnobs } from '@storybook/addon-knobs';24import { createType } from 'storybook-root';25addDecorator(withKnobs);

Using AI Code Generation

1import { createType } from "storybook-root";2const myType = createType({3 fields: {4 },5});6export default myType;7import { createType } from "storybook-root";8const myType = createType({9 fields: {10 },11});12export default myType;13import { createType } from "storybook-root";14const myType = createType({15 fields: {16 },17});18export default myType;19import { createType } from "storybook-root";20const myType = createType({21 fields: {22 },23});24export default myType;25import { createType } from "storybook-root";26const myType = createType({27 fields: {28 },29});30export default myType;31import { createType } from "storybook-root";32const myType = createType({33 fields: {34 },35});36export default myType;37import { createType } from "storybook-root";38const myType = createType({39 fields: {40 },41});42export default myType;

Using AI Code Generation

1import { createType } from 'storybook-root-cause';2const type = createType('test');3type.log('test');4import { createType } from 'storybook-root-cause';5const type = createType('test');6type.log('test');7import { createType } from 'storybook-root-cause';8const type = createType('test');9type.log('test');10import { createType } from 'storybook-root-cause';11const type = createType('test');12type.log('test');13import { createType } from 'storybook-root-cause';14const type = createType('test');15type.log('test');16import { createType } from 'storybook-root-cause';17const type = createType('test');18type.log('test');19import { createType } from 'storybook-root-cause';20const type = createType('test');21type.log('test');22import { createType } from 'storybook-root-cause';23const type = createType('test');24type.log('test');25import { createType } from 'storybook-root-cause';26const type = createType('test');27type.log('test');28import { createType } from 'storybook-root-cause';29const type = createType('test');30type.log('test');31import { createType } from 'storybook-root-cause';32const type = createType('test');33type.log('test');34import { createType } from 'storybook-root-cause';35const type = createType('test');36type.log('test');

Using AI Code Generation

1import { createType } from 'storybook-root'2const Type = createType({3 props: {4 },5})6import Type from 'test.js'7export default {8 components: { Type },9 props: {10 name: {11 },12 color: {13 },14 },15}16import Type from 'storybook/components/Type'17export default {18 argTypes: {19 name: {20 control: {21 },22 },23 color: {24 control: {25 },26 },27 },28}29const Template = (args, { argTypes }) => ({30 props: Object.keys(argTypes),31 components: { Type },32})33export const TypeStory = Template.bind({})34TypeStory.args = {35}36import TypeStory from 'storybook/stories/Type'37import { Meta, Story, Preview, Props } from '@storybook/addon-docs/blocks'38<Meta title="Type" component={Type} />39<Props of={Type} />40import TypeStory from 'storybook/stories/Type'41import TypeStory from 'storybook/stories/Type'42export default {43 components: { TypeStory },44}45import Type from 'storybook/components

Using AI Code Generation

1const { createType } = require('storybook-root');2const { Type } = require('js-data');3const { createType } = require('storybook-root');4const { Type } = require('js-data');5const Post = createType({6 schema: {7 properties: {8 id: { type: 'number' },9 title: { type: 'string' }10 }11 }12});13module.exports = Post;14const { createType } = require('storybook-root');15const { Type } = require('js-data');16const { createType } = require('storybook-root');17const { Type } = require('js-data');18const Post = createType({19 schema: {20 properties: {21 id: { type: 'number' },22 title: { type: 'string' }23 }24 }25});26module.exports = Post;

Using AI Code Generation

1const { createType } = require('storybook-root');2const { string, number, bool, array, object } = createType('MyComponent');3const { createType } = require('storybook-root');4const { string, number, bool, array, object } = createType('MyComponent');5const { createType } = require('storybook-root');6const { string, number, bool, array, object } = createType('MyComponent');7const { createType } = require('storybook-root');8const { string, number, bool, array, object } = createType('MyComponent');9const { createType } = require('storybook-root');10const { string, number, bool, array, object } = createType('MyComponent');11const { createType } = require('storybook-root');12const { string, number, bool, array, object } = createType('MyComponent');13const { createType } = require('storybook-root');14const { string, number, bool, array, object } = createType('MyComponent');15const { createType } = require('storybook-root');16const { string, number, bool, array, object } = createType('MyComponent');17const { createType } = require('storybook-root');18const { string, number, bool, array, object } = createType('MyComponent');19const { createType } = require('storybook-root');20const { string, number, bool, array, object } = createType('MyComponent');21const { createType } = require('storybook-root');22const { string, number, bool, array, object } = createType('MyComponent');23const { createType } = require('storybook-root');24const { string, number, bool, array, object } = createType('MyComponent');

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

• JUnit Tutorial
• TestNG Tutorial
• Webdriver Tutorial
• WebDriverIO Tutorial
• Protractor Tutorial
• Selenium 4 Tutorial
• Jenkins Tutorial
• NUnit Tutorial
• Jest Tutorial
• Playwright Tutorial
• Cypress Tutorial
• PyTest Tutorial

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run storybook-root automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

View sample repo View DocumentationSign up Free

›

_