Enforce a consistent code style for contains tests

jdesrosiers · jdesrosiers · commit da687ca56ec7 · 2021-06-16T11:37:32.000-07:00
diff --git a/tests/draft-future/contains.json b/tests/draft-future/contains.json
@@ -2,7 +2,7 @@
     {
         "description": "contains keyword validation",
         "schema": {
-            "contains": {"minimum": 5}
+            "contains": { "minimum": 5 }
         },
         "tests": [
             {
@@ -62,7 +62,7 @@
     },
     {
         "description": "contains keyword with boolean schema true",
-        "schema": {"contains": true},
+        "schema": { "contains": true },
         "tests": [
             {
                 "description": "any non-empty array is valid",
@@ -78,7 +78,7 @@
     },
     {
         "description": "contains keyword with boolean schema false",
-        "schema": {"contains": false},
+        "schema": { "contains": false },
         "tests": [
             {
                 "description": "any non-empty array is invalid",
@@ -106,22 +106,22 @@
         "tests": [
             {
                 "description": "matches items, does not match contains",
-                "data": [ 2, 4, 8 ],
+                "data": [2, 4, 8],
                 "valid": false
             },
             {
                 "description": "does not match items, matches contains",
-                "data": [ 3, 6, 9 ],
+                "data": [3, 6, 9],
                 "valid": false
             },
             {
                 "description": "matches both items and contains",
-                "data": [ 6, 12 ],
+                "data": [6, 12],
                 "valid": true
             },
             {
                 "description": "matches neither items nor contains",
-                "data": [ 1, 5 ],
+                "data": [1, 5],
                 "valid": false
             }
         ]
diff --git a/tests/draft-future/maxContains.json b/tests/draft-future/maxContains.json
@@ -7,71 +7,71 @@
         "tests": [
             {
                 "description": "one item valid against lone maxContains",
-                "data": [ 1 ],
+                "data": [1],
                 "valid": true
             },
             {
                 "description": "two items still valid against lone maxContains",
-                "data": [ 1, 2 ],
+                "data": [1, 2],
                 "valid": true
             }
         ]
     },
     {
         "description": "maxContains with contains",
         "schema": {
-            "contains": {"const": 1},
+            "contains": { "const": 1 },
             "maxContains": 1
         },
         "tests": [
             {
                 "description": "empty data",
-                "data": [ ],
+                "data": [],
                 "valid": false
             },
             {
                 "description": "all elements match, valid maxContains",
-                "data": [ 1 ],
+                "data": [1],
                 "valid": true
             },
             {
                 "description": "all elements match, invalid maxContains",
-                "data": [ 1, 1 ],
+                "data": [1, 1],
                 "valid": false
             },
             {
                 "description": "some elements match, valid maxContains",
-                "data": [ 1, 2 ],
+                "data": [1, 2],
                 "valid": true
             },
             {
                 "description": "some elements match, invalid maxContains",
-                "data": [ 1, 2, 1 ],
+                "data": [1, 2, 1],
                 "valid": false
             }
         ]
     },
     {
         "description": "minContains < maxContains",
         "schema": {
-            "contains": {"const": 1},
+            "contains": { "const": 1 },
             "minContains": 1,
             "maxContains": 3
         },
         "tests": [
             {
                 "description": "actual < minContains < maxContains",
-                "data": [ ],
+                "data": [],
                 "valid": false
             },
             {
                 "description": "minContains < actual < maxContains",
-                "data": [ 1, 1 ],
+                "data": [1, 1],
                 "valid": true
             },
             {
                 "description": "minContains < maxContains < actual",
-                "data": [ 1, 1, 1, 1 ],
+                "data": [1, 1, 1, 1],
                 "valid": false
             }
         ]
diff --git a/tests/draft-future/minContains.json b/tests/draft-future/minContains.json
@@ -7,7 +7,7 @@
         "tests": [
             {
                 "description": "one item valid against lone minContains",
-                "data": [ 1 ],
+                "data": [1],
                 "valid": true
             },
             {
@@ -20,151 +20,151 @@
     {
         "description": "minContains=1 with contains",
         "schema": {
-            "contains": {"const": 1},
+            "contains": { "const": 1 },
             "minContains": 1
         },
         "tests": [
             {
                 "description": "empty data",
-                "data": [ ],
+                "data": [],
                 "valid": false
             },
             {
                 "description": "no elements match",
-                "data": [ 2 ],
+                "data": [2],
                 "valid": false
             },
             {
                 "description": "single element matches, valid minContains",
-                "data": [ 1 ],
+                "data": [1],
                 "valid": true
             },
             {
                 "description": "some elements match, valid minContains",
-                "data": [ 1, 2 ],
+                "data": [1, 2],
                 "valid": true
             },
             {
                 "description": "all elements match, valid minContains",
-                "data": [ 1, 1 ],
+                "data": [1, 1],
                 "valid": true
             }
         ]
     },
     {
         "description": "minContains=2 with contains",
         "schema": {
-            "contains": {"const": 1},
+            "contains": { "const": 1 },
             "minContains": 2
         },
         "tests": [
             {
                 "description": "empty data",
-                "data": [ ],
+                "data": [],
                 "valid": false
             },
             {
                 "description": "all elements match, invalid minContains",
-                "data": [ 1 ],
+                "data": [1],
                 "valid": false
             },
             {
                 "description": "some elements match, invalid minContains",
-                "data": [ 1, 2 ],
+                "data": [1, 2],
                 "valid": false
             },
             {
                 "description": "all elements match, valid minContains (exactly as needed)",
-                "data": [ 1, 1 ],
+                "data": [1, 1],
                 "valid": true
             },
             {
                 "description": "all elements match, valid minContains (more than needed)",
-                "data": [ 1, 1, 1 ],
+                "data": [1, 1, 1],
                 "valid": true
             },
             {
                 "description": "some elements match, valid minContains",
-                "data": [ 1, 2, 1 ],
+                "data": [1, 2, 1],
                 "valid": true
             }
         ]
     },
     {
         "description": "maxContains = minContains",
         "schema": {
-            "contains": {"const": 1},
+            "contains": { "const": 1 },
             "maxContains": 2,
             "minContains": 2
         },
         "tests": [
             {
                 "description": "empty data",
-                "data": [ ],
+                "data": [],
                 "valid": false
             },
             {
                 "description": "all elements match, invalid minContains",
-                "data": [ 1 ],
+                "data": [1],
                 "valid": false
             },
             {
                 "description": "all elements match, invalid maxContains",
-                "data": [ 1, 1, 1 ],
+                "data": [1, 1, 1],
                 "valid": false
             },
             {
                 "description": "all elements match, valid maxContains and minContains",
-                "data": [ 1, 1 ],
+                "data": [1, 1],
                 "valid": true
             }
         ]
     },
     {
         "description": "maxContains < minContains",
         "schema": {
-            "contains": {"const": 1},
+            "contains": { "const": 1 },
             "maxContains": 1,
             "minContains": 3
         },
         "tests": [
             {
                 "description": "empty data",
-                "data": [ ],
+                "data": [],
                 "valid": false
             },
             {
                 "description": "invalid minContains",
-                "data": [ 1 ],
+                "data": [1],
                 "valid": false
             },
             {
                 "description": "invalid maxContains",
-                "data": [ 1, 1, 1 ],
+                "data": [1, 1, 1],
                 "valid": false
             },
             {
                 "description": "invalid maxContains and minContains",
-                "data": [ 1, 1 ],
+                "data": [1, 1],
                 "valid": false
             }
         ]
     },
     {
         "description": "minContains = 0",
         "schema": {
-            "contains": {"const": 1},
+            "contains": { "const": 1 },
             "minContains": 0
         },
         "tests": [
             {
                 "description": "empty data",
-                "data": [ ],
+                "data": [],
                 "valid": true
             },
             {
                 "description": "minContains = 0 makes contains always pass",
-                "data": [ 2 ],
+                "data": [2],
                 "valid": true
             }
         ]

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`{`
`3`	`3`	`"description": "contains keyword validation",`
`4`	`4`	`"schema": {`
`5`		`- "contains": {"minimum": 5}`
	`5`	`+ "contains": { "minimum": 5 }`
`6`	`6`	`},`
`7`	`7`	`"tests": [`
`8`	`8`	`{`
`@@ -62,7 +62,7 @@`
`62`	`62`	`},`
`63`	`63`	`{`
`64`	`64`	`"description": "contains keyword with boolean schema true",`
`65`		`- "schema": {"contains": true},`
	`65`	`+ "schema": { "contains": true },`
`66`	`66`	`"tests": [`
`67`	`67`	`{`
`68`	`68`	`"description": "any non-empty array is valid",`
`@@ -78,7 +78,7 @@`
`78`	`78`	`},`
`79`	`79`	`{`
`80`	`80`	`"description": "contains keyword with boolean schema false",`
`81`		`- "schema": {"contains": false},`
	`81`	`+ "schema": { "contains": false },`
`82`	`82`	`"tests": [`
`83`	`83`	`{`
`84`	`84`	`"description": "any non-empty array is invalid",`
`@@ -106,22 +106,22 @@`
`106`	`106`	`"tests": [`
`107`	`107`	`{`
`108`	`108`	`"description": "matches items, does not match contains",`
`109`		`- "data": [ 2, 4, 8 ],`
	`109`	`+ "data": [2, 4, 8],`
`110`	`110`	`"valid": false`
`111`	`111`	`},`
`112`	`112`	`{`
`113`	`113`	`"description": "does not match items, matches contains",`
`114`		`- "data": [ 3, 6, 9 ],`
	`114`	`+ "data": [3, 6, 9],`
`115`	`115`	`"valid": false`
`116`	`116`	`},`
`117`	`117`	`{`
`118`	`118`	`"description": "matches both items and contains",`
`119`		`- "data": [ 6, 12 ],`
	`119`	`+ "data": [6, 12],`
`120`	`120`	`"valid": true`
`121`	`121`	`},`
`122`	`122`	`{`
`123`	`123`	`"description": "matches neither items nor contains",`
`124`		`- "data": [ 1, 5 ],`
	`124`	`+ "data": [1, 5],`
`125`	`125`	`"valid": false`
`126`	`126`	`}`
`127`	`127`	`]`
Original file line number	Diff line number	Diff line change
`@@ -7,71 +7,71 @@`
`7`	`7`	`"tests": [`
`8`	`8`	`{`
`9`	`9`	`"description": "one item valid against lone maxContains",`
`10`		`- "data": [ 1 ],`
	`10`	`+ "data": [1],`
`11`	`11`	`"valid": true`
`12`	`12`	`},`
`13`	`13`	`{`
`14`	`14`	`"description": "two items still valid against lone maxContains",`
`15`		`- "data": [ 1, 2 ],`
	`15`	`+ "data": [1, 2],`
`16`	`16`	`"valid": true`
`17`	`17`	`}`
`18`	`18`	`]`
`19`	`19`	`},`
`20`	`20`	`{`
`21`	`21`	`"description": "maxContains with contains",`
`22`	`22`	`"schema": {`
`23`		`- "contains": {"const": 1},`
	`23`	`+ "contains": { "const": 1 },`
`24`	`24`	`"maxContains": 1`
`25`	`25`	`},`
`26`	`26`	`"tests": [`
`27`	`27`	`{`
`28`	`28`	`"description": "empty data",`
`29`		`- "data": [ ],`
	`29`	`+ "data": [],`
`30`	`30`	`"valid": false`
`31`	`31`	`},`
`32`	`32`	`{`
`33`	`33`	`"description": "all elements match, valid maxContains",`
`34`		`- "data": [ 1 ],`
	`34`	`+ "data": [1],`
`35`	`35`	`"valid": true`
`36`	`36`	`},`
`37`	`37`	`{`
`38`	`38`	`"description": "all elements match, invalid maxContains",`
`39`		`- "data": [ 1, 1 ],`
	`39`	`+ "data": [1, 1],`
`40`	`40`	`"valid": false`
`41`	`41`	`},`
`42`	`42`	`{`
`43`	`43`	`"description": "some elements match, valid maxContains",`
`44`		`- "data": [ 1, 2 ],`
	`44`	`+ "data": [1, 2],`
`45`	`45`	`"valid": true`
`46`	`46`	`},`
`47`	`47`	`{`
`48`	`48`	`"description": "some elements match, invalid maxContains",`
`49`		`- "data": [ 1, 2, 1 ],`
	`49`	`+ "data": [1, 2, 1],`
`50`	`50`	`"valid": false`
`51`	`51`	`}`
`52`	`52`	`]`
`53`	`53`	`},`
`54`	`54`	`{`
`55`	`55`	`"description": "minContains < maxContains",`
`56`	`56`	`"schema": {`
`57`		`- "contains": {"const": 1},`
	`57`	`+ "contains": { "const": 1 },`
`58`	`58`	`"minContains": 1,`
`59`	`59`	`"maxContains": 3`
`60`	`60`	`},`
`61`	`61`	`"tests": [`
`62`	`62`	`{`
`63`	`63`	`"description": "actual < minContains < maxContains",`
`64`		`- "data": [ ],`
	`64`	`+ "data": [],`
`65`	`65`	`"valid": false`
`66`	`66`	`},`
`67`	`67`	`{`
`68`	`68`	`"description": "minContains < actual < maxContains",`
`69`		`- "data": [ 1, 1 ],`
	`69`	`+ "data": [1, 1],`
`70`	`70`	`"valid": true`
`71`	`71`	`},`
`72`	`72`	`{`
`73`	`73`	`"description": "minContains < maxContains < actual",`
`74`		`- "data": [ 1, 1, 1, 1 ],`
	`74`	`+ "data": [1, 1, 1, 1],`
`75`	`75`	`"valid": false`
`76`	`76`	`}`
`77`	`77`	`]`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`"tests": [`
`8`	`8`	`{`
`9`	`9`	`"description": "one item valid against lone minContains",`
`10`		`- "data": [ 1 ],`
	`10`	`+ "data": [1],`
`11`	`11`	`"valid": true`
`12`	`12`	`},`
`13`	`13`	`{`
`@@ -20,151 +20,151 @@`
`20`	`20`	`{`
`21`	`21`	`"description": "minContains=1 with contains",`
`22`	`22`	`"schema": {`
`23`		`- "contains": {"const": 1},`
	`23`	`+ "contains": { "const": 1 },`
`24`	`24`	`"minContains": 1`
`25`	`25`	`},`
`26`	`26`	`"tests": [`
`27`	`27`	`{`
`28`	`28`	`"description": "empty data",`
`29`		`- "data": [ ],`
	`29`	`+ "data": [],`
`30`	`30`	`"valid": false`
`31`	`31`	`},`
`32`	`32`	`{`
`33`	`33`	`"description": "no elements match",`
`34`		`- "data": [ 2 ],`
	`34`	`+ "data": [2],`
`35`	`35`	`"valid": false`
`36`	`36`	`},`
`37`	`37`	`{`
`38`	`38`	`"description": "single element matches, valid minContains",`
`39`		`- "data": [ 1 ],`
	`39`	`+ "data": [1],`
`40`	`40`	`"valid": true`
`41`	`41`	`},`
`42`	`42`	`{`
`43`	`43`	`"description": "some elements match, valid minContains",`
`44`		`- "data": [ 1, 2 ],`
	`44`	`+ "data": [1, 2],`
`45`	`45`	`"valid": true`
`46`	`46`	`},`
`47`	`47`	`{`
`48`	`48`	`"description": "all elements match, valid minContains",`
`49`		`- "data": [ 1, 1 ],`
	`49`	`+ "data": [1, 1],`
`50`	`50`	`"valid": true`
`51`	`51`	`}`
`52`	`52`	`]`
`53`	`53`	`},`
`54`	`54`	`{`
`55`	`55`	`"description": "minContains=2 with contains",`
`56`	`56`	`"schema": {`
`57`		`- "contains": {"const": 1},`
	`57`	`+ "contains": { "const": 1 },`
`58`	`58`	`"minContains": 2`
`59`	`59`	`},`
`60`	`60`	`"tests": [`
`61`	`61`	`{`
`62`	`62`	`"description": "empty data",`
`63`		`- "data": [ ],`
	`63`	`+ "data": [],`
`64`	`64`	`"valid": false`
`65`	`65`	`},`
`66`	`66`	`{`
`67`	`67`	`"description": "all elements match, invalid minContains",`
`68`		`- "data": [ 1 ],`
	`68`	`+ "data": [1],`
`69`	`69`	`"valid": false`
`70`	`70`	`},`
`71`	`71`	`{`
`72`	`72`	`"description": "some elements match, invalid minContains",`
`73`		`- "data": [ 1, 2 ],`
	`73`	`+ "data": [1, 2],`
`74`	`74`	`"valid": false`
`75`	`75`	`},`
`76`	`76`	`{`
`77`	`77`	`"description": "all elements match, valid minContains (exactly as needed)",`
`78`		`- "data": [ 1, 1 ],`
	`78`	`+ "data": [1, 1],`
`79`	`79`	`"valid": true`
`80`	`80`	`},`
`81`	`81`	`{`
`82`	`82`	`"description": "all elements match, valid minContains (more than needed)",`
`83`		`- "data": [ 1, 1, 1 ],`
	`83`	`+ "data": [1, 1, 1],`
`84`	`84`	`"valid": true`
`85`	`85`	`},`
`86`	`86`	`{`
`87`	`87`	`"description": "some elements match, valid minContains",`
`88`		`- "data": [ 1, 2, 1 ],`
	`88`	`+ "data": [1, 2, 1],`
`89`	`89`	`"valid": true`
`90`	`90`	`}`
`91`	`91`	`]`
`92`	`92`	`},`
`93`	`93`	`{`
`94`	`94`	`"description": "maxContains = minContains",`
`95`	`95`	`"schema": {`
`96`		`- "contains": {"const": 1},`
	`96`	`+ "contains": { "const": 1 },`
`97`	`97`	`"maxContains": 2,`
`98`	`98`	`"minContains": 2`
`99`	`99`	`},`
`100`	`100`	`"tests": [`
`101`	`101`	`{`
`102`	`102`	`"description": "empty data",`
`103`		`- "data": [ ],`
	`103`	`+ "data": [],`
`104`	`104`	`"valid": false`
`105`	`105`	`},`
`106`	`106`	`{`
`107`	`107`	`"description": "all elements match, invalid minContains",`
`108`		`- "data": [ 1 ],`
	`108`	`+ "data": [1],`
`109`	`109`	`"valid": false`
`110`	`110`	`},`
`111`	`111`	`{`
`112`	`112`	`"description": "all elements match, invalid maxContains",`
`113`		`- "data": [ 1, 1, 1 ],`
	`113`	`+ "data": [1, 1, 1],`
`114`	`114`	`"valid": false`
`115`	`115`	`},`
`116`	`116`	`{`
`117`	`117`	`"description": "all elements match, valid maxContains and minContains",`
`118`		`- "data": [ 1, 1 ],`
	`118`	`+ "data": [1, 1],`
`119`	`119`	`"valid": true`
`120`	`120`	`}`
`121`	`121`	`]`
`122`	`122`	`},`
`123`	`123`	`{`
`124`	`124`	`"description": "maxContains < minContains",`
`125`	`125`	`"schema": {`
`126`		`- "contains": {"const": 1},`
	`126`	`+ "contains": { "const": 1 },`
`127`	`127`	`"maxContains": 1,`
`128`	`128`	`"minContains": 3`
`129`	`129`	`},`
`130`	`130`	`"tests": [`
`131`	`131`	`{`
`132`	`132`	`"description": "empty data",`
`133`		`- "data": [ ],`
	`133`	`+ "data": [],`
`134`	`134`	`"valid": false`
`135`	`135`	`},`
`136`	`136`	`{`
`137`	`137`	`"description": "invalid minContains",`
`138`		`- "data": [ 1 ],`
	`138`	`+ "data": [1],`
`139`	`139`	`"valid": false`
`140`	`140`	`},`
`141`	`141`	`{`
`142`	`142`	`"description": "invalid maxContains",`
`143`		`- "data": [ 1, 1, 1 ],`
	`143`	`+ "data": [1, 1, 1],`
`144`	`144`	`"valid": false`
`145`	`145`	`},`
`146`	`146`	`{`
`147`	`147`	`"description": "invalid maxContains and minContains",`
`148`		`- "data": [ 1, 1 ],`
	`148`	`+ "data": [1, 1],`
`149`	`149`	`"valid": false`
`150`	`150`	`}`
`151`	`151`	`]`
`152`	`152`	`},`
`153`	`153`	`{`
`154`	`154`	`"description": "minContains = 0",`
`155`	`155`	`"schema": {`
`156`		`- "contains": {"const": 1},`
	`156`	`+ "contains": { "const": 1 },`
`157`	`157`	`"minContains": 0`
`158`	`158`	`},`
`159`	`159`	`"tests": [`
`160`	`160`	`{`
`161`	`161`	`"description": "empty data",`
`162`		`- "data": [ ],`
	`162`	`+ "data": [],`
`163`	`163`	`"valid": true`
`164`	`164`	`},`
`165`	`165`	`{`
`166`	`166`	`"description": "minContains = 0 makes contains always pass",`
`167`		`- "data": [ 2 ],`
	`167`	`+ "data": [2],`
`168`	`168`	`"valid": true`
`169`	`169`	`}`
`170`	`170`	`]`