Blame view

node_modules/json-schema-traverse/spec/index.spec.js 3.07 KB
ce4c83ff   wxy   初始提交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
  'use strict';
  
  var traverse = require('../index');
  var assert = require('assert');
  
  describe('json-schema-traverse', function() {
    var calls;
  
    beforeEach(function() {
      calls = [];
    });
  
    it('should traverse all keywords containing schemas recursively', function() {
      var schema = require('./fixtures/schema').schema;
      var expectedCalls = require('./fixtures/schema').expectedCalls;
  
      traverse(schema, callback);
      assert.deepStrictEqual(calls, expectedCalls);
    });
  
  
    describe('allKeys option', function() {
      var schema = {
        someObject: {
          minimum: 1,
          maximum: 2
        }
      };
  
      it('should traverse objects with allKeys: true option', function() {
        // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
        var expectedCalls = [
          [schema, '', schema, undefined, undefined, undefined, undefined],
          [schema.someObject, '/someObject', schema, '', 'someObject', schema, undefined]
        ];
  
        traverse(schema, {allKeys: true}, callback);
        assert.deepStrictEqual(calls, expectedCalls);
      });
  
  
      it('should NOT traverse objects with allKeys: false option', function() {
        // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
        var expectedCalls = [
          [schema, '', schema, undefined, undefined, undefined, undefined]
        ];
  
        traverse(schema, {allKeys: false}, callback);
        assert.deepStrictEqual(calls, expectedCalls);
      });
  
  
      it('should NOT traverse objects without allKeys option', function() {
        // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
        var expectedCalls = [
          [schema, '', schema, undefined, undefined, undefined, undefined]
        ];
  
        traverse(schema, callback);
        assert.deepStrictEqual(calls, expectedCalls);
      });
  
  
      it('should NOT travers objects in standard keywords which value is not a schema', function() {
        var schema2 = {
          const: {foo: 'bar'},
          enum: ['a', 'b'],
          required: ['foo'],
          another: {
  
          },
          patternProperties: {}, // will not traverse - no properties
          dependencies: true, // will not traverse - invalid
          properties: {
            smaller: {
              type: 'number'
            },
            larger: {
              type: 'number',
              minimum: {$data: '1/smaller'}
            }
          }
        };
  
        // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
        var expectedCalls = [
          [schema2, '', schema2, undefined, undefined, undefined, undefined],
          [schema2.another, '/another', schema2, '', 'another', schema2, undefined],
          [schema2.properties.smaller, '/properties/smaller', schema2, '', 'properties', schema2, 'smaller'],
          [schema2.properties.larger, '/properties/larger', schema2, '', 'properties', schema2, 'larger'],
        ];
  
        traverse(schema2, {allKeys: true}, callback);
        assert.deepStrictEqual(calls, expectedCalls);
      });
    });
  
  
    function callback() {
      calls.push(Array.prototype.slice.call(arguments));
    }
  });