/implementations/server/swagger-java-react-ts-webpack/swagger-editor/test/plugins/validation/semantic/security.js

https://gitlab.com/abh1/web-applications-study-group · JavaScript · 135 lines · 128 code · 7 blank · 0 comment · 0 complexity · c56ed3bde0f5e4755c97f6e3d361b51b MD5 · raw file 

    

  1. import expect from "expect"
    2. 

  2. import { validate } from "plugins/validation/semantic-validators/validators/security"
    3. 

  3. 

  4. describe("validation plugin - semantic - security", () => {
    5. 

  5.   it("should return an error when an operation references a non-existing security scope", () => {
    6. 

  6.     const spec = {
    7. 

  7.       "securityDefinitions": {
    8. 

  8.         "api_key": {
    9. 

  9.           "type": "apiKey",
    10. 

  10.           "name": "apikey",
    11. 

  11.           "in": "query",
    12. 

  12.           "scopes": {
    13. 

  13.             "asdf": "blah blah"
    14. 

  14.           }
    15. 

  15.         }
    16. 

  16.       },
    17. 

  17.       "paths": {
    18. 

  18.         "/": {
    19. 

  19.           "get": {
    20. 

  20.             "description": "asdf",
    21. 

  21.             "security": [
    22. 

  22.               {
    23. 

  23.                 "api_key": [
    24. 

  24.                   "write:pets"
    25. 

  25.                 ]
    26. 

  26.               }
    27. 

  27.             ]
    28. 

  28.           }
    29. 

  29.         }
    30. 

  30.       }
    31. 

  31.     }
    32. 

  32. 

  33.     let res = validate({ resolvedSpec: spec })
    34. 

  34.     expect(res.errors.length).toEqual(1)
    35. 

  35.     expect(res.errors[0].path).toEqual(["paths", "/", "get", "security", "0", "0"])
    36. 

  36.     expect(res.errors[0].message).toEqual("Security scope definition write:pets could not be resolved")
    37. 

  37.     expect(res.warnings.length).toEqual(0)
    38. 

  38.   })
    39. 

  39.   it("should return an error when an operation references a security definition with no scopes", () => {
    40. 

  40.     const spec = {
    41. 

  41.       "securityDefinitions": {
    42. 

  42.         "api_key": {
    43. 

  43.           "type": "apiKey",
    44. 

  44.           "name": "apikey",
    45. 

  45.           "in": "query"
    46. 

  46.         }
    47. 

  47.       },
    48. 

  48.       "paths": {
    49. 

  49.         "/": {
    50. 

  50.           "get": {
    51. 

  51.             "description": "asdf",
    52. 

  52.             "security": [
    53. 

  53.               {
    54. 

  54.                 "api_key": [
    55. 

  55.                   "write:pets"
    56. 

  56.                 ]
    57. 

  57.               }
    58. 

  58.             ]
    59. 

  59.           }
    60. 

  60.         }
    61. 

  61.       }
    62. 

  62.     }
    63. 

  63. 

  64.     let res = validate({ resolvedSpec: spec })
    65. 

  65.     expect(res.errors.length).toEqual(1)
    66. 

  66.     expect(res.errors[0].path).toEqual(["paths", "/", "get", "security", "0", "0"])
    67. 

  67.     expect(res.errors[0].message).toEqual("Security scope definition write:pets could not be resolved")
    68. 

  68.     expect(res.warnings.length).toEqual(0)
    69. 

  69.   })
    70. 

  70. 

  71.   it("should return an error when an operation references a non-existing security definition", () => {
    72. 

  72.     const spec = {
    73. 

  73.       "securityDefinitions": {
    74. 

  74.         "api_key": {
    75. 

  75.           "type": "apiKey",
    76. 

  76.           "name": "apikey",
    77. 

  77.           "in": "query"
    78. 

  78.         }
    79. 

  79.       },
    80. 

  80.       "paths": {
    81. 

  81.         "/": {
    82. 

  82.           "get": {
    83. 

  83.             "description": "asdf",
    84. 

  84.             "security": [
    85. 

  85.               {
    86. 

  86.                 "fictional_security_definition": [
    87. 

  87.                   "write:pets"
    88. 

  88.                 ]
    89. 

  89.               }
    90. 

  90.             ]
    91. 

  91.           }
    92. 

  92.         }
    93. 

  93.       }
    94. 

  94.     }
    95. 

  95. 

  96.     let res = validate({ resolvedSpec: spec })
    97. 

  97.     expect(res.errors.length).toEqual(1)
    98. 

  98.     expect(res.errors[0].path).toEqual(["paths", "/", "get", "security", "0"])
    99. 

  99.     expect(res.errors[0].message).toEqual("security requirements must match a security definition")
    100. 

  100.     expect(res.warnings.length).toEqual(0)
    101. 

  101.   })
    102. 

  102. 

  103.   it("should not return an error when an operation references an existing security scope", () => {
    104. 

  104.     const spec = {
    105. 

  105.       "securityDefinitions": {
    106. 

  106.         "api_key": {
    107. 

  107.           "type": "apiKey",
    108. 

  108.           "name": "apikey",
    109. 

  109.           "in": "query",
    110. 

  110.           "scopes": {
    111. 

  111.             "write:pets": "write to pets"
    112. 

  112.           }
    113. 

  113.         }
    114. 

  114.       },
    115. 

  115.       "paths": {
    116. 

  116.         "/": {
    117. 

  117.           "get": {
    118. 

  118.             "description": "asdf",
    119. 

  119.             "security": [
    120. 

  120.               {
    121. 

  121.                 "api_key": [
    122. 

  122.                   "write:pets"
    123. 

  123.                 ]
    124. 

  124.               }
    125. 

  125.             ]
    126. 

  126.           }
    127. 

  127.         }
    128. 

  128.       }
    129. 

  129.     }
    130. 

  130. 

  131.     let res = validate({ resolvedSpec: spec })
    132. 

  132.     expect(res.errors.length).toEqual(0)
    133. 

  133.     expect(res.warnings.length).toEqual(0)
    134. 

  134.   })
    135. 

  135. })
    136.