github.com/anth0d/nomad@v0.0.0-20221214183521-ae3a0a2cad06/ui/tests/unit/abilities/abstract-test.js (about)

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