pastebin

Paste Search Dynamic
Recent pastes
Expect array
  1. <?php
  2.  
  3. declare(strict_types=1);
  4.  
  5. use NetteSchemaExpect;
  6. use NetteSchemaHelpers;
  7. use NetteSchemaProcessor;
  8. use TesterAssert;
  9.  
  10.  
  11. require __DIR__ . '/../bootstrap.php';
  12.  
  13.  
  14. test('without default value', function () {
  15.         $schema = Expect::array();
  16.  
  17.         assert::same([], (new Processor)->process($schema, []));
  18.  
  19.         assert::same([1, 2, 3], (new Processor)->process($schema, [1, 2, 3]));
  20.  
  21.         assert::same(['key' => 'val'], (new Processor)->process($schema, ['key' => 'val']));
  22.  
  23.         checkValidationErrors(function () use ($schema) {
  24.                 (new Processor)->process($schema, 'one');
  25.         }, ["The item expects to be array, 'one' given."]);
  26.  
  27.         checkValidationErrors(function () use ($schema) {
  28.                 (new Processor)->process($schema, true);
  29.         }, ['The item expects to be array, true given.']);
  30.  
  31.         checkValidationErrors(function () use ($schema) {
  32.                 (new Processor)->process($schema, 123);
  33.         }, ['The item expects to be array, 123 given.']);
  34.  
  35.         assert::same([], (new Processor)->process($schema, null));
  36. });
  37.  
  38.  
  39. test('not merging', function () {
  40.         $schema = Expect::array([
  41.                 'key1' => 'val1',
  42.                 'key2' => 'val2',
  43.                 'val3',
  44.                 'arr' => ['item'],
  45.         ])->mergeDefaults(false);
  46.  
  47.         assert::same([], (new Processor)->process($schema, []));
  48.  
  49.         assert::same(
  50.                 [1, 2, 3],
  51.                 (new Processor)->process($schema, [1, 2, 3])
  52.         );
  53. });
  54.  
  55.  
  56. test('merging', function () {
  57.         $schema = Expect::array([
  58.                 'key1' => 'val1',
  59.                 'key2' => 'val2',
  60.                 'val3',
  61.                 'arr' => ['item'],
  62.         ]);
  63.  
  64.         assert::same([
  65.                 'key1' => 'val1',
  66.                 'key2' => 'val2',
  67.                 'val3',
  68.                 'arr' => ['item'],
  69.         ], (new Processor)->process($schema, []));
  70.  
  71.         assert::same(
  72.                 [
  73.                         'key1' => 'val1',
  74.                         'key2' => 'val2',
  75.                         'val3',
  76.                         'arr' => ['item'],
  77.                         1, 2, 3,
  78.                 ],
  79.                 (new Processor)->process($schema, [1, 2, 3])
  80.         );
  81.  
  82.         assert::same(
  83.                 [
  84.                         'key1' => 'newval',
  85.                         'key2' => 'val2',
  86.                         'val3',
  87.                         'arr' => ['item', 'newitem'],
  88.                         'key3' => 'newval',
  89.                         'newval3',
  90.                 ],
  91.                 (new Processor)->process($schema, [
  92.                         'key1' => 'newval',
  93.                         'key3' => 'newval',
  94.                         'newval3',
  95.                         'arr' => ['newitem'],
  96.                 ])
  97.         );
  98.  
  99.         assert::same(
  100.                 [
  101.                         'key1' => 'newval',
  102.                         'key3' => 'newval',
  103.                         'newval3',
  104.                         'arr' => ['newitem'],
  105.                 ],
  106.                 (new Processor)->process($schema, [
  107.                         Helpers::PREVENT_MERGING => true,
  108.                         'key1' => 'newval',
  109.                         'key3' => 'newval',
  110.                         'newval3',
  111.                         'arr' => ['newitem'],
  112.                 ])
  113.         );
  114.  
  115.         assert::same(
  116.                 [
  117.                         'key1' => 'newval',
  118.                         'key2' => 'val2',
  119.                         'val3',
  120.                         'arr' => ['newitem'],
  121.                         'key3' => 'newval',
  122.                         'newval3',
  123.                 ],
  124.                 (new Processor)->process($schema, [
  125.                         'key1' => 'newval',
  126.                         'key3' => 'newval',
  127.                         'newval3',
  128.                         'arr' => [Helpers::PREVENT_MERGING => true, 'newitem'],
  129.                 ])
  130.         );
  131. });
  132.  
  133.  
  134. test('merging & other items validation', function () {
  135.         $schema = Expect::array([
  136.                 'key1' => 'val1',
  137.                 'key2' => 'val2',
  138.                 'val3',
  139.         ])->items('string');
  140.  
  141.         assert::same([
  142.                 'key1' => 'val1',
  143.                 'key2' => 'val2',
  144.                 'val3',
  145.         ], (new Processor)->process($schema, []));
  146.  
  147.         checkValidationErrors(function () use ($schema) {
  148.                 (new Processor)->process($schema, [1, 2, 3]);
  149.         }, [
  150.                 "The item '0' expects to be string, 1 given.",
  151.                 "The item '1' expects to be string, 2 given.",
  152.                 "The item '2' expects to be string, 3 given.",
  153.         ]);
  154.  
  155.         assert::same(
  156.                 [
  157.                         'key1' => 'newval',
  158.                         'key2' => 'val2',
  159.                         'val3',
  160.                         'key3' => 'newval',
  161.                         'newval3',
  162.                 ],
  163.                 (new Processor)->process($schema, [
  164.                         'key1' => 'newval',
  165.                         'key3' => 'newval',
  166.                         'newval3',
  167.                 ])
  168.         );
  169. });
  170.  
  171.  
  172. test('merging & other items validation', function () {
  173.         $schema = Expect::array()->items('string');
  174.  
  175.         assert::same([
  176.                 'key1' => 'val1',
  177.                 'key2' => 'val2',
  178.                 'val3',
  179.         ], $schema->merge([
  180.                 'key1' => 'val1',
  181.                 'key2' => 'val2',
  182.                 'val3',
  183.         ], null));
  184.  
  185.         assert::same(
  186.                 [
  187.                         'key1' => 'newval',
  188.                         'key2' => 'val2',
  189.                         'val3',
  190.                         'key3' => 'newval',
  191.                         'newval3',
  192.                 ],
  193.                 $schema->merge([
  194.                         'key1' => 'newval',
  195.                         'key3' => 'newval',
  196.                         'newval3',
  197.                 ], [
  198.                         'key1' => 'val1',
  199.                         'key2' => 'val2',
  200.                         'val3',
  201.                 ])
  202.         );
  203. });
  204.  
  205.  
  206. test('items() & scalar', function () {
  207.         $schema = Expect::array([
  208.                 'a' => 'defval',
  209.         ])->items('string');
  210.  
  211.         assert::same(['a' => 'defval'], (new Processor)->process($schema, []));
  212.  
  213.         checkValidationErrors(function () use ($schema) {
  214.                 (new Processor)->process($schema, [1, 2, 3]);
  215.         }, [
  216.                 "The item '0' expects to be string, 1 given.",
  217.                 "The item '1' expects to be string, 2 given.",
  218.                 "The item '2' expects to be string, 3 given.",
  219.         ]);
  220.  
  221.         assert::same(['a' => 'val'], (new Processor)->process($schema, ['a' => 'val']));
  222.  
  223.         checkValidationErrors(function () use ($schema) {
  224.                 (new Processor)->process($schema, ['a' => null]);
  225.         }, ["The item 'a' expects to be string, null given."]);
  226.  
  227.         checkValidationErrors(function () use ($schema) {
  228.                 (new Processor)->process($schema, ['b' => 123]);
  229.         }, ["The item 'b' expects to be string, 123 given."]);
  230.  
  231.         checkValidationErrors(function () use ($schema) {
  232.                 (new Processor)->process($schema, ['b' => null]);
  233.         }, ["The item 'b' expects to be string, null given."]);
  234.  
  235.         assert::same(['a' => 'defval', 'b' => 'val'], (new Processor)->process($schema, ['b' => 'val']));
  236. });
  237.  
  238.  
  239. test('items() & structure', function () {
  240.         $schema = Expect::array([
  241.                 'a' => 'defval',
  242.         ])->items(Expect::structure(['k' => Expect::string()]));
  243.  
  244.         assert::same(['a' => 'defval'], (new Processor)->process($schema, []));
  245.  
  246.         checkValidationErrors(function () use ($schema) {
  247.                 (new Processor)->process($schema, ['a' => 'val']);
  248.         }, ["The item 'a' expects to be array, 'val' given."]);
  249.  
  250.         checkValidationErrors(function () use ($schema) {
  251.                 (new Processor)->process($schema, [1, 2, 3]);
  252.         }, [
  253.                 "The item '0' expects to be array, 1 given.",
  254.                 "The item '1' expects to be array, 2 given.",
  255.                 "The item '2' expects to be array, 3 given.",
  256.         ]);
  257.  
  258.         checkValidationErrors(function () use ($schema) {
  259.                 (new Processor)->process($schema, ['b' => 'val']);
  260.         }, ["The item 'b' expects to be array, 'val' given."]);
  261.  
  262.         checkValidationErrors(function () use ($schema) {
  263.                 (new Processor)->process($schema, ['b' => ['a' => 'val']]);
  264.         }, ["Unexpected item 'bĀ ā€ŗĀ a', did you mean 'k'?"]);
  265.  
  266.         assert::equal(
  267.                 ['a' => 'defval', 'b' => (object) ['k' => 'val']],
  268.                 (new Processor)->process($schema, ['b' => ['k' => 'val']])
  269.         );
  270. });
  271.  
  272.  
  273. test('arrayOf() & scalar', function () {
  274.         $schema = Expect::arrayOf('string|int');
  275.  
  276.         assert::same([], (new Processor)->process($schema, []));
  277.  
  278.         assert::same([1, 2, 3], (new Processor)->process($schema, [1, 2, 3]));
  279.  
  280.         assert::same([10 => 20], (new Processor)->process($schema, [10 => 20]));
  281.  
  282.         checkValidationErrors(function () use ($schema) {
  283.                 (new Processor)->process($schema, [1, 2, false]);
  284.         }, ["The item '2' expects to be string or int, false given."]);
  285.  
  286.         assert::same(['key' => 'val'], (new Processor)->process($schema, ['key' => 'val']));
  287. });
  288.  
  289.  
  290. test('arrayOf() & keys', function () {
  291.         $schema = Expect::arrayOf('string|int', Expect::string()->pattern('w+'));
  292.  
  293.         assert::same([], (new Processor)->process($schema, []));
  294.  
  295.         checkValidationErrors(function () use ($schema) {
  296.                 (new Processor)->process($schema, [1, '#' => 2]);
  297.         }, [
  298.                 "The key of item '0' expects to be string, 0 given.",
  299.                 "The key of item '#' expects to match pattern '\w+', '#' given.",
  300.         ]);
  301.  
  302.         assert::same(['key' => 'val'], (new Processor)->process($schema, ['key' => 'val']));
  303. });
  304.  
  305.  
  306. test('arrayOf() & keys II.', function () {
  307.         $schema = Expect::arrayOf('string|int', Expect::string()->before('strrev'));
  308.  
  309.         assert::same(['yek' => 'val'], (new Processor)->process($schema, ['key' => 'val']));
  310. });
  311.  
  312.  
  313. test('arrayOf() error', function () {
  314.         assert::exception(function () {
  315.                 Expect::arrayOf(['a' => Expect::string()]);
  316.         }, TypeError::class);
  317. });
  318.  
  319.  
  320. test('type[]', function () {
  321.         $schema = Expect::type('int[]');
  322.  
  323.         assert::same([], (new Processor)->process($schema, null));
  324.  
  325.         assert::same([], (new Processor)->process($schema, []));
  326.  
  327.         assert::same([1, 2, 3], (new Processor)->process($schema, [1, 2, 3]));
  328.  
  329.         checkValidationErrors(function () use ($schema) {
  330.                 (new Processor)->process($schema, [1, 2, false]);
  331.         }, ['The item expects to be int[], array given.']);
  332.  
  333.         assert::same(['key' => 1], (new Processor)->process($schema, ['key' => 1]));
  334. });
Parsed in 7.111 seconds