github.com/hernad/nomad@v1.6.112/ui/tests/unit/abilities/abstract-test.js (about)

     1  /**
     2   * Copyright (c) HashiCorp, Inc.
     3   * SPDX-License-Identifier: MPL-2.0
     4   */
     5  
     6  import { module, test } from 'qunit';
     7  import { setupTest } from 'ember-qunit';
     8  import Service from '@ember/service';
     9  import setupAbility from 'nomad-ui/tests/helpers/setup-ability';
    10  
    11  module('Unit | Ability | abstract', function (hooks) {
    12    setupTest(hooks);
    13    setupAbility('abstract')(hooks);
    14    hooks.beforeEach(function () {
    15      const mockSystem = Service.extend({
    16        init(...args) {
    17          this._super(...args);
    18  
    19          this.features = this.features || [];
    20        },
    21      });
    22  
    23      this.owner.register('service:system', mockSystem);
    24    });
    25  
    26    module('#_findMatchingNamespace', function () {
    27      test('it returns * if no matching namespace and * is specified', function (assert) {
    28        const policyNamespaces = [
    29          {
    30            Capabilities: [
    31              'list-jobs',
    32              'parse-job',
    33              'read-job',
    34              'csi-list-volume',
    35              'csi-read-volume',
    36              'read-job-scaling',
    37              'list-scaling-policies',
    38              'read-scaling-policy',
    39              'scale-job',
    40              'submit-job',
    41              'dispatch-job',
    42              'read-logs',
    43              'read-fs',
    44              'alloc-exec',
    45              'alloc-lifecycle',
    46              'csi-mount-volume',
    47              'csi-write-volume',
    48              'submit-recommendation',
    49            ],
    50            Name: 'default',
    51            Policy: 'write',
    52            Variables: {
    53              Paths: [
    54                {
    55                  Capabilities: ['write', 'read', 'destroy', 'list'],
    56                  PathSpec: 'project/*',
    57                },
    58                {
    59                  Capabilities: ['write', 'read', 'destroy', 'list'],
    60                  PathSpec: '*',
    61                },
    62                {
    63                  Capabilities: ['read', 'list'],
    64                  PathSpec: 'system/*',
    65                },
    66                {
    67                  Capabilities: [],
    68                  PathSpec: 'pablo/*',
    69                },
    70              ],
    71            },
    72          },
    73          {
    74            Capabilities: [
    75              'list-jobs',
    76              'parse-job',
    77              'read-job',
    78              'csi-list-volume',
    79              'csi-read-volume',
    80              'read-job-scaling',
    81              'list-scaling-policies',
    82              'read-scaling-policy',
    83              'scale-job',
    84              'submit-job',
    85              'dispatch-job',
    86              'read-logs',
    87              'read-fs',
    88              'alloc-exec',
    89              'alloc-lifecycle',
    90              'csi-mount-volume',
    91              'csi-write-volume',
    92              'submit-recommendation',
    93            ],
    94            Name: '*',
    95            Policy: 'write',
    96            Variables: {
    97              Paths: [
    98                {
    99                  Capabilities: ['write', 'read', 'destroy', 'list'],
   100                  PathSpec: 'project/*',
   101                },
   102                {
   103                  Capabilities: ['write', 'read', 'list'],
   104                  PathSpec: '*',
   105                },
   106                {
   107                  Capabilities: ['read', 'list'],
   108                  PathSpec: 'system/*',
   109                },
   110              ],
   111            },
   112          },
   113          {
   114            Capabilities: [
   115              'list-jobs',
   116              'parse-job',
   117              'read-job',
   118              'csi-list-volume',
   119              'csi-read-volume',
   120              'read-job-scaling',
   121              'list-scaling-policies',
   122              'read-scaling-policy',
   123              'scale-job',
   124              'submit-job',
   125              'dispatch-job',
   126              'read-logs',
   127              'read-fs',
   128              'alloc-exec',
   129              'alloc-lifecycle',
   130              'csi-mount-volume',
   131              'csi-write-volume',
   132              'submit-recommendation',
   133            ],
   134            Name: 'madness',
   135            Policy: 'write',
   136            Variables: {
   137              Paths: [
   138                {
   139                  Capabilities: ['read', 'list', 'write'],
   140                  PathSpec: '*',
   141                },
   142                {
   143                  Capabilities: ['read', 'list'],
   144                  PathSpec: 'system/*',
   145                },
   146              ],
   147            },
   148          },
   149        ];
   150  
   151        assert.equal(
   152          this.ability._findMatchingNamespace(policyNamespaces, 'pablo'),
   153          '*'
   154        );
   155      });
   156  
   157      test('it returns the matching namespace if it exists', function (assert) {
   158        const policyNamespaces = [
   159          {
   160            Capabilities: [
   161              'list-jobs',
   162              'parse-job',
   163              'read-job',
   164              'csi-list-volume',
   165              'csi-read-volume',
   166              'read-job-scaling',
   167              'list-scaling-policies',
   168              'read-scaling-policy',
   169              'scale-job',
   170              'submit-job',
   171              'dispatch-job',
   172              'read-logs',
   173              'read-fs',
   174              'alloc-exec',
   175              'alloc-lifecycle',
   176              'csi-mount-volume',
   177              'csi-write-volume',
   178              'submit-recommendation',
   179            ],
   180            Name: 'default',
   181            Policy: 'write',
   182            Variables: {
   183              Paths: [
   184                {
   185                  Capabilities: ['write', 'read', 'destroy', 'list'],
   186                  PathSpec: 'project/*',
   187                },
   188                {
   189                  Capabilities: ['write', 'read', 'destroy', 'list'],
   190                  PathSpec: '*',
   191                },
   192                {
   193                  Capabilities: ['read', 'list'],
   194                  PathSpec: 'system/*',
   195                },
   196                {
   197                  Capabilities: [],
   198                  PathSpec: 'pablo/*',
   199                },
   200              ],
   201            },
   202          },
   203          {
   204            Capabilities: [
   205              'list-jobs',
   206              'parse-job',
   207              'read-job',
   208              'csi-list-volume',
   209              'csi-read-volume',
   210              'read-job-scaling',
   211              'list-scaling-policies',
   212              'read-scaling-policy',
   213              'scale-job',
   214              'submit-job',
   215              'dispatch-job',
   216              'read-logs',
   217              'read-fs',
   218              'alloc-exec',
   219              'alloc-lifecycle',
   220              'csi-mount-volume',
   221              'csi-write-volume',
   222              'submit-recommendation',
   223            ],
   224            Name: '*',
   225            Policy: 'write',
   226            Variables: {
   227              Paths: [
   228                {
   229                  Capabilities: ['write', 'read', 'destroy', 'list'],
   230                  PathSpec: 'project/*',
   231                },
   232                {
   233                  Capabilities: ['write', 'read', 'list'],
   234                  PathSpec: '*',
   235                },
   236                {
   237                  Capabilities: ['read', 'list'],
   238                  PathSpec: 'system/*',
   239                },
   240              ],
   241            },
   242          },
   243          {
   244            Capabilities: [
   245              'list-jobs',
   246              'parse-job',
   247              'read-job',
   248              'csi-list-volume',
   249              'csi-read-volume',
   250              'read-job-scaling',
   251              'list-scaling-policies',
   252              'read-scaling-policy',
   253              'scale-job',
   254              'submit-job',
   255              'dispatch-job',
   256              'read-logs',
   257              'read-fs',
   258              'alloc-exec',
   259              'alloc-lifecycle',
   260              'csi-mount-volume',
   261              'csi-write-volume',
   262              'submit-recommendation',
   263            ],
   264            Name: 'pablo',
   265            Policy: 'write',
   266            Variables: {
   267              Paths: [
   268                {
   269                  Capabilities: ['read', 'list', 'write'],
   270                  PathSpec: '*',
   271                },
   272                {
   273                  Capabilities: ['read', 'list'],
   274                  PathSpec: 'system/*',
   275                },
   276              ],
   277            },
   278          },
   279        ];
   280  
   281        assert.equal(
   282          this.ability._findMatchingNamespace(policyNamespaces, 'pablo'),
   283          'pablo'
   284        );
   285      });
   286  
   287      test('it handles glob matching suffix', function (assert) {
   288        const policyNamespaces = [
   289          {
   290            Capabilities: [
   291              'list-jobs',
   292              'parse-job',
   293              'read-job',
   294              'csi-list-volume',
   295              'csi-read-volume',
   296              'read-job-scaling',
   297              'list-scaling-policies',
   298              'read-scaling-policy',
   299              'scale-job',
   300              'submit-job',
   301              'dispatch-job',
   302              'read-logs',
   303              'read-fs',
   304              'alloc-exec',
   305              'alloc-lifecycle',
   306              'csi-mount-volume',
   307              'csi-write-volume',
   308              'submit-recommendation',
   309            ],
   310            Name: 'default',
   311            Policy: 'write',
   312            Variables: {
   313              Paths: [
   314                {
   315                  Capabilities: ['write', 'read', 'destroy', 'list'],
   316                  PathSpec: 'project/*',
   317                },
   318                {
   319                  Capabilities: ['write', 'read', 'destroy', 'list'],
   320                  PathSpec: '*',
   321                },
   322                {
   323                  Capabilities: ['read', 'list'],
   324                  PathSpec: 'system/*',
   325                },
   326                {
   327                  Capabilities: [],
   328                  PathSpec: 'pablo/*',
   329                },
   330              ],
   331            },
   332          },
   333          {
   334            Capabilities: [
   335              'list-jobs',
   336              'parse-job',
   337              'read-job',
   338              'csi-list-volume',
   339              'csi-read-volume',
   340              'read-job-scaling',
   341              'list-scaling-policies',
   342              'read-scaling-policy',
   343              'scale-job',
   344              'submit-job',
   345              'dispatch-job',
   346              'read-logs',
   347              'read-fs',
   348              'alloc-exec',
   349              'alloc-lifecycle',
   350              'csi-mount-volume',
   351              'csi-write-volume',
   352              'submit-recommendation',
   353            ],
   354            Name: '*',
   355            Policy: 'write',
   356            Variables: {
   357              Paths: [
   358                {
   359                  Capabilities: ['write', 'read', 'destroy', 'list'],
   360                  PathSpec: 'project/*',
   361                },
   362                {
   363                  Capabilities: ['write', 'read', 'list'],
   364                  PathSpec: '*',
   365                },
   366                {
   367                  Capabilities: ['read', 'list'],
   368                  PathSpec: 'system/*',
   369                },
   370              ],
   371            },
   372          },
   373          {
   374            Capabilities: [
   375              'list-jobs',
   376              'parse-job',
   377              'read-job',
   378              'csi-list-volume',
   379              'csi-read-volume',
   380              'read-job-scaling',
   381              'list-scaling-policies',
   382              'read-scaling-policy',
   383              'scale-job',
   384              'submit-job',
   385              'dispatch-job',
   386              'read-logs',
   387              'read-fs',
   388              'alloc-exec',
   389              'alloc-lifecycle',
   390              'csi-mount-volume',
   391              'csi-write-volume',
   392              'submit-recommendation',
   393            ],
   394            Name: 'pablo/*',
   395            Policy: 'write',
   396            Variables: {
   397              Paths: [
   398                {
   399                  Capabilities: ['read', 'list', 'write'],
   400                  PathSpec: '*',
   401                },
   402                {
   403                  Capabilities: ['read', 'list'],
   404                  PathSpec: 'system/*',
   405                },
   406              ],
   407            },
   408          },
   409        ];
   410  
   411        assert.equal(
   412          this.ability._findMatchingNamespace(
   413            policyNamespaces,
   414            'pablo/picasso/rothkos/rilkes'
   415          ),
   416          'pablo/*'
   417        );
   418      });
   419  
   420      test('it handles glob matching prefix', function (assert) {
   421        const policyNamespaces = [
   422          {
   423            Capabilities: [
   424              'list-jobs',
   425              'parse-job',
   426              'read-job',
   427              'csi-list-volume',
   428              'csi-read-volume',
   429              'read-job-scaling',
   430              'list-scaling-policies',
   431              'read-scaling-policy',
   432              'scale-job',
   433              'submit-job',
   434              'dispatch-job',
   435              'read-logs',
   436              'read-fs',
   437              'alloc-exec',
   438              'alloc-lifecycle',
   439              'csi-mount-volume',
   440              'csi-write-volume',
   441              'submit-recommendation',
   442            ],
   443            Name: 'default',
   444            Policy: 'write',
   445            Variables: {
   446              Paths: [
   447                {
   448                  Capabilities: ['write', 'read', 'destroy', 'list'],
   449                  PathSpec: 'project/*',
   450                },
   451                {
   452                  Capabilities: ['write', 'read', 'destroy', 'list'],
   453                  PathSpec: '*',
   454                },
   455                {
   456                  Capabilities: ['read', 'list'],
   457                  PathSpec: 'system/*',
   458                },
   459                {
   460                  Capabilities: [],
   461                  PathSpec: 'pablo/*',
   462                },
   463              ],
   464            },
   465          },
   466          {
   467            Capabilities: [
   468              'list-jobs',
   469              'parse-job',
   470              'read-job',
   471              'csi-list-volume',
   472              'csi-read-volume',
   473              'read-job-scaling',
   474              'list-scaling-policies',
   475              'read-scaling-policy',
   476              'scale-job',
   477              'submit-job',
   478              'dispatch-job',
   479              'read-logs',
   480              'read-fs',
   481              'alloc-exec',
   482              'alloc-lifecycle',
   483              'csi-mount-volume',
   484              'csi-write-volume',
   485              'submit-recommendation',
   486            ],
   487            Name: '*',
   488            Policy: 'write',
   489            Variables: {
   490              Paths: [
   491                {
   492                  Capabilities: ['write', 'read', 'destroy', 'list'],
   493                  PathSpec: 'project/*',
   494                },
   495                {
   496                  Capabilities: ['write', 'read', 'list'],
   497                  PathSpec: '*',
   498                },
   499                {
   500                  Capabilities: ['read', 'list'],
   501                  PathSpec: 'system/*',
   502                },
   503              ],
   504            },
   505          },
   506          {
   507            Capabilities: [
   508              'list-jobs',
   509              'parse-job',
   510              'read-job',
   511              'csi-list-volume',
   512              'csi-read-volume',
   513              'read-job-scaling',
   514              'list-scaling-policies',
   515              'read-scaling-policy',
   516              'scale-job',
   517              'submit-job',
   518              'dispatch-job',
   519              'read-logs',
   520              'read-fs',
   521              'alloc-exec',
   522              'alloc-lifecycle',
   523              'csi-mount-volume',
   524              'csi-write-volume',
   525              'submit-recommendation',
   526            ],
   527            Name: '*/rilkes',
   528            Policy: 'write',
   529            Variables: {
   530              Paths: [
   531                {
   532                  Capabilities: ['read', 'list', 'write'],
   533                  PathSpec: '*',
   534                },
   535                {
   536                  Capabilities: ['read', 'list'],
   537                  PathSpec: 'system/*',
   538                },
   539              ],
   540            },
   541          },
   542        ];
   543  
   544        assert.equal(
   545          this.ability._findMatchingNamespace(
   546            policyNamespaces,
   547            'pablo/picasso/rothkos/rilkes'
   548          ),
   549          '*/rilkes'
   550        );
   551      });
   552  
   553      test('it returns default if no matching namespace and no matching globs', function (assert) {
   554        const policyNamespaces = [
   555          {
   556            Capabilities: [
   557              'list-jobs',
   558              'parse-job',
   559              'read-job',
   560              'csi-list-volume',
   561              'csi-read-volume',
   562              'read-job-scaling',
   563              'list-scaling-policies',
   564              'read-scaling-policy',
   565              'scale-job',
   566              'submit-job',
   567              'dispatch-job',
   568              'read-logs',
   569              'read-fs',
   570              'alloc-exec',
   571              'alloc-lifecycle',
   572              'csi-mount-volume',
   573              'csi-write-volume',
   574              'submit-recommendation',
   575            ],
   576            Name: 'default',
   577            Policy: 'write',
   578            Variables: {
   579              Paths: [
   580                {
   581                  Capabilities: ['write', 'read', 'destroy', 'list'],
   582                  PathSpec: 'project/*',
   583                },
   584                {
   585                  Capabilities: ['write', 'read', 'destroy', 'list'],
   586                  PathSpec: '*',
   587                },
   588                {
   589                  Capabilities: ['read', 'list'],
   590                  PathSpec: 'system/*',
   591                },
   592                {
   593                  Capabilities: [],
   594                  PathSpec: 'pablo/*',
   595                },
   596              ],
   597            },
   598          },
   599          {
   600            Capabilities: [
   601              'list-jobs',
   602              'parse-job',
   603              'read-job',
   604              'csi-list-volume',
   605              'csi-read-volume',
   606              'read-job-scaling',
   607              'list-scaling-policies',
   608              'read-scaling-policy',
   609              'scale-job',
   610              'submit-job',
   611              'dispatch-job',
   612              'read-logs',
   613              'read-fs',
   614              'alloc-exec',
   615              'alloc-lifecycle',
   616              'csi-mount-volume',
   617              'csi-write-volume',
   618              'submit-recommendation',
   619            ],
   620            Name: 'pablo/*',
   621            Policy: 'write',
   622            Variables: {
   623              Paths: [
   624                {
   625                  Capabilities: ['read', 'list', 'write'],
   626                  PathSpec: '*',
   627                },
   628                {
   629                  Capabilities: ['read', 'list'],
   630                  PathSpec: 'system/*',
   631                },
   632              ],
   633            },
   634          },
   635        ];
   636  
   637        assert.equal(
   638          this.ability._findMatchingNamespace(policyNamespaces, 'carter'),
   639          'default'
   640        );
   641      });
   642    });
   643  });