source.dussan.org Git - sonarqube.git/blob

   1 // Jest Snapshot v1, https://goo.gl/fbAQLP
   2
   3 exports[`should render correctly: changed value 1`] = `
   4 <div
   5   className="settings-definition settings-definition-changed"
   6   data-key="foo"
   7 >
   8   <div
   9     className="settings-definition-left"
  10   >
  11     <h3
  12       className="settings-definition-name"
  13       title="property.foo.name"
  14     >
  15       property.foo.name
  16     </h3>
  17     <div
  18       className="markdown small spacer-top"
  19       dangerouslySetInnerHTML={
  20         {
  21           "__html": "property.foo.description",
  22         }
  23       }
  24     />
  25     <Tooltip
  26       overlay="settings.key_x.foo"
  27     >
  28       <div
  29         className="settings-definition-key note little-spacer-top"
  30       >
  31         settings.key_x.foo
  32       </div>
  33     </Tooltip>
  34   </div>
  35   <div
  36     className="settings-definition-right"
  37   >
  38     <div
  39       className="settings-definition-state"
  40     />
  41     <form
  42       onSubmit={[Function]}
  43     >
  44       <Input
  45         hasValueChanged={true}
  46         isEditing={false}
  47         onCancel={[MockFunction]}
  48         onChange={[MockFunction]}
  49         onEditing={[MockFunction]}
  50         onSave={[MockFunction]}
  51         setting={
  52           {
  53             "definition": {
  54               "category": "foo category",
  55               "fields": [],
  56               "key": "foo",
  57               "options": [],
  58               "subCategory": "foo subCat",
  59             },
  60             "hasValue": false,
  61             "key": "foo",
  62           }
  63         }
  64         value="new value"
  65       />
  66       <DefinitionActions
  67         changedValue="new value"
  68         hasError={false}
  69         hasValueChanged={true}
  70         isDefault={false}
  71         isEditing={false}
  72         onCancel={[MockFunction]}
  73         onReset={[MockFunction]}
  74         onSave={[MockFunction]}
  75         setting={
  76           {
  77             "definition": {
  78               "category": "foo category",
  79               "fields": [],
  80               "key": "foo",
  81               "options": [],
  82               "subCategory": "foo subCat",
  83             },
  84             "hasValue": false,
  85             "key": "foo",
  86           }
  87         }
  88       />
  89     </form>
  90   </div>
  91 </div>
  92 `;
  93
  94 exports[`should render correctly: in error 1`] = `
  95 <div
  96   className="settings-definition"
  97   data-key="foo"
  98 >
  99   <div
 100     className="settings-definition-left"
 101   >
 102     <h3
 103       className="settings-definition-name"
 104       title="property.foo.name"
 105     >
 106       property.foo.name
 107     </h3>
 108     <div
 109       className="markdown small spacer-top"
 110       dangerouslySetInnerHTML={
 111         {
 112           "__html": "property.foo.description",
 113         }
 114       }
 115     />
 116     <Tooltip
 117       overlay="settings.key_x.foo"
 118     >
 119       <div
 120         className="settings-definition-key note little-spacer-top"
 121       >
 122         settings.key_x.foo
 123       </div>
 124     </Tooltip>
 125   </div>
 126   <div
 127     className="settings-definition-right"
 128   >
 129     <div
 130       className="settings-definition-state"
 131     >
 132       <span
 133         className="text-danger"
 134       >
 135         <AlertErrorIcon
 136           className="spacer-right"
 137         />
 138         <span>
 139           settings.state.validation_failed.validation message
 140         </span>
 141       </span>
 142     </div>
 143     <form
 144       onSubmit={[Function]}
 145     >
 146       <Input
 147         hasValueChanged={false}
 148         isEditing={false}
 149         onCancel={[MockFunction]}
 150         onChange={[MockFunction]}
 151         onEditing={[MockFunction]}
 152         onSave={[MockFunction]}
 153         setting={
 154           {
 155             "definition": {
 156               "category": "foo category",
 157               "fields": [],
 158               "key": "foo",
 159               "options": [],
 160               "subCategory": "foo subCat",
 161             },
 162             "hasValue": false,
 163             "key": "foo",
 164           }
 165         }
 166       />
 167       <DefinitionActions
 168         hasError={true}
 169         hasValueChanged={false}
 170         isDefault={false}
 171         isEditing={false}
 172         onCancel={[MockFunction]}
 173         onReset={[MockFunction]}
 174         onSave={[MockFunction]}
 175         setting={
 176           {
 177             "definition": {
 178               "category": "foo category",
 179               "fields": [],
 180               "key": "foo",
 181               "options": [],
 182               "subCategory": "foo subCat",
 183             },
 184             "hasValue": false,
 185             "key": "foo",
 186           }
 187         }
 188       />
 189     </form>
 190   </div>
 191 </div>
 192 `;
 193
 194 exports[`should render correctly: loading 1`] = `
 195 <div
 196   className="settings-definition"
 197   data-key="foo"
 198 >
 199   <div
 200     className="settings-definition-left"
 201   >
 202     <h3
 203       className="settings-definition-name"
 204       title="property.foo.name"
 205     >
 206       property.foo.name
 207     </h3>
 208     <div
 209       className="markdown small spacer-top"
 210       dangerouslySetInnerHTML={
 211         {
 212           "__html": "property.foo.description",
 213         }
 214       }
 215     />
 216     <Tooltip
 217       overlay="settings.key_x.foo"
 218     >
 219       <div
 220         className="settings-definition-key note little-spacer-top"
 221       >
 222         settings.key_x.foo
 223       </div>
 224     </Tooltip>
 225   </div>
 226   <div
 227     className="settings-definition-right"
 228   >
 229     <div
 230       className="settings-definition-state"
 231     >
 232       <span
 233         className="text-info"
 234       >
 235         <i
 236           className="spinner spacer-right"
 237         />
 238         settings.state.saving
 239       </span>
 240     </div>
 241     <form
 242       onSubmit={[Function]}
 243     >
 244       <Input
 245         hasValueChanged={false}
 246         isEditing={false}
 247         onCancel={[MockFunction]}
 248         onChange={[MockFunction]}
 249         onEditing={[MockFunction]}
 250         onSave={[MockFunction]}
 251         setting={
 252           {
 253             "definition": {
 254               "category": "foo category",
 255               "fields": [],
 256               "key": "foo",
 257               "options": [],
 258               "subCategory": "foo subCat",
 259             },
 260             "hasValue": false,
 261             "key": "foo",
 262           }
 263         }
 264       />
 265       <DefinitionActions
 266         hasError={false}
 267         hasValueChanged={false}
 268         isDefault={false}
 269         isEditing={false}
 270         onCancel={[MockFunction]}
 271         onReset={[MockFunction]}
 272         onSave={[MockFunction]}
 273         setting={
 274           {
 275             "definition": {
 276               "category": "foo category",
 277               "fields": [],
 278               "key": "foo",
 279               "options": [],
 280               "subCategory": "foo subCat",
 281             },
 282             "hasValue": false,
 283             "key": "foo",
 284           }
 285         }
 286       />
 287     </form>
 288   </div>
 289 </div>
 290 `;
 291
 292 exports[`should render correctly: original value 1`] = `
 293 <div
 294   className="settings-definition"
 295   data-key="foo"
 296 >
 297   <div
 298     className="settings-definition-left"
 299   >
 300     <h3
 301       className="settings-definition-name"
 302       title="property.foo.name"
 303     >
 304       property.foo.name
 305     </h3>
 306     <div
 307       className="markdown small spacer-top"
 308       dangerouslySetInnerHTML={
 309         {
 310           "__html": "property.foo.description",
 311         }
 312       }
 313     />
 314     <Tooltip
 315       overlay="settings.key_x.foo"
 316     >
 317       <div
 318         className="settings-definition-key note little-spacer-top"
 319       >
 320         settings.key_x.foo
 321       </div>
 322     </Tooltip>
 323   </div>
 324   <div
 325     className="settings-definition-right"
 326   >
 327     <div
 328       className="settings-definition-state"
 329     />
 330     <form
 331       onSubmit={[Function]}
 332     >
 333       <Input
 334         hasValueChanged={false}
 335         isEditing={false}
 336         onCancel={[MockFunction]}
 337         onChange={[MockFunction]}
 338         onEditing={[MockFunction]}
 339         onSave={[MockFunction]}
 340         setting={
 341           {
 342             "definition": {
 343               "category": "foo category",
 344               "fields": [],
 345               "key": "foo",
 346               "options": [],
 347               "subCategory": "foo subCat",
 348             },
 349             "hasValue": true,
 350             "key": "foo",
 351             "value": "original value",
 352           }
 353         }
 354         value="original value"
 355       />
 356       <DefinitionActions
 357         hasError={false}
 358         hasValueChanged={false}
 359         isDefault={false}
 360         isEditing={false}
 361         onCancel={[MockFunction]}
 362         onReset={[MockFunction]}
 363         onSave={[MockFunction]}
 364         setting={
 365           {
 366             "definition": {
 367               "category": "foo category",
 368               "fields": [],
 369               "key": "foo",
 370               "options": [],
 371               "subCategory": "foo subCat",
 372             },
 373             "hasValue": true,
 374             "key": "foo",
 375             "value": "original value",
 376           }
 377         }
 378       />
 379     </form>
 380   </div>
 381 </div>
 382 `;
 383
 384 exports[`should render correctly: success 1`] = `
 385 <div
 386   className="settings-definition"
 387   data-key="foo"
 388 >
 389   <div
 390     className="settings-definition-left"
 391   >
 392     <h3
 393       className="settings-definition-name"
 394       title="property.foo.name"
 395     >
 396       property.foo.name
 397     </h3>
 398     <div
 399       className="markdown small spacer-top"
 400       dangerouslySetInnerHTML={
 401         {
 402           "__html": "property.foo.description",
 403         }
 404       }
 405     />
 406     <Tooltip
 407       overlay="settings.key_x.foo"
 408     >
 409       <div
 410         className="settings-definition-key note little-spacer-top"
 411       >
 412         settings.key_x.foo
 413       </div>
 414     </Tooltip>
 415   </div>
 416   <div
 417     className="settings-definition-right"
 418   >
 419     <div
 420       className="settings-definition-state"
 421     >
 422       <span
 423         className="text-success"
 424       >
 425         <AlertSuccessIcon
 426           className="spacer-right"
 427         />
 428         settings.state.saved
 429       </span>
 430     </div>
 431     <form
 432       onSubmit={[Function]}
 433     >
 434       <Input
 435         hasValueChanged={false}
 436         isEditing={false}
 437         onCancel={[MockFunction]}
 438         onChange={[MockFunction]}
 439         onEditing={[MockFunction]}
 440         onSave={[MockFunction]}
 441         setting={
 442           {
 443             "definition": {
 444               "category": "foo category",
 445               "fields": [],
 446               "key": "foo",
 447               "options": [],
 448               "subCategory": "foo subCat",
 449             },
 450             "hasValue": false,
 451             "key": "foo",
 452           }
 453         }
 454       />
 455       <DefinitionActions
 456         hasError={false}
 457         hasValueChanged={false}
 458         isDefault={false}
 459         isEditing={false}
 460         onCancel={[MockFunction]}
 461         onReset={[MockFunction]}
 462         onSave={[MockFunction]}
 463         setting={
 464           {
 465             "definition": {
 466               "category": "foo category",
 467               "fields": [],
 468               "key": "foo",
 469               "options": [],
 470               "subCategory": "foo subCat",
 471             },
 472             "hasValue": false,
 473             "key": "foo",
 474           }
 475         }
 476       />
 477     </form>
 478   </div>
 479 </div>
 480 `;
 481
 482 exports[`should render correctly: with description 1`] = `
 483 <div
 484   className="settings-definition"
 485   data-key="foo"
 486 >
 487   <div
 488     className="settings-definition-left"
 489   >
 490     <h3
 491       className="settings-definition-name"
 492       title="property.foo.name"
 493     >
 494       property.foo.name
 495     </h3>
 496     <div
 497       className="markdown small spacer-top"
 498       dangerouslySetInnerHTML={
 499         {
 500           "__html": "property.foo.description",
 501         }
 502       }
 503     />
 504     <Tooltip
 505       overlay="settings.key_x.foo"
 506     >
 507       <div
 508         className="settings-definition-key note little-spacer-top"
 509       >
 510         settings.key_x.foo
 511       </div>
 512     </Tooltip>
 513   </div>
 514   <div
 515     className="settings-definition-right"
 516   >
 517     <div
 518       className="settings-definition-state"
 519     />
 520     <form
 521       onSubmit={[Function]}
 522     >
 523       <Input
 524         hasValueChanged={false}
 525         isEditing={false}
 526         onCancel={[MockFunction]}
 527         onChange={[MockFunction]}
 528         onEditing={[MockFunction]}
 529         onSave={[MockFunction]}
 530         setting={
 531           {
 532             "definition": {
 533               "category": "foo category",
 534               "description": "description",
 535               "fields": [],
 536               "key": "foo",
 537               "options": [],
 538               "subCategory": "foo subCat",
 539             },
 540             "hasValue": false,
 541             "key": "foo",
 542           }
 543         }
 544       />
 545       <DefinitionActions
 546         hasError={false}
 547         hasValueChanged={false}
 548         isDefault={false}
 549         isEditing={false}
 550         onCancel={[MockFunction]}
 551         onReset={[MockFunction]}
 552         onSave={[MockFunction]}
 553         setting={
 554           {
 555             "definition": {
 556               "category": "foo category",
 557               "description": "description",
 558               "fields": [],
 559               "key": "foo",
 560               "options": [],
 561               "subCategory": "foo subCat",
 562             },
 563             "hasValue": false,
 564             "key": "foo",
 565           }
 566         }
 567       />
 568     </form>
 569   </div>
 570 </div>
 571 `;