github.com/hernad/nomad@v1.6.112/ui/tests/unit/models/task-group-test.js (about)

     1  /**
     2   * Copyright (c) HashiCorp, Inc.
     3   * SPDX-License-Identifier: MPL-2.0
     4   */
     5  
     6  import { get } from '@ember/object';
     7  import { module, test } from 'qunit';
     8  import { setupTest } from 'ember-qunit';
     9  
    10  import { run } from '@ember/runloop';
    11  
    12  const sum = (list, key) => list.reduce((sum, item) => sum + get(item, key), 0);
    13  
    14  module('Unit | Model | task-group', function (hooks) {
    15    setupTest(hooks);
    16  
    17    test("should expose reserved resource stats as aggregates of each task's reserved resources", function (assert) {
    18      const taskGroup = run(() =>
    19        this.owner.lookup('service:store').createRecord('task-group', {
    20          name: 'group-example',
    21          tasks: [
    22            {
    23              name: 'task-one',
    24              driver: 'docker',
    25              reservedMemory: 512,
    26              reservedCPU: 500,
    27              reservedDisk: 1024,
    28            },
    29            {
    30              name: 'task-two',
    31              driver: 'docker',
    32              reservedMemory: 256,
    33              reservedCPU: 1000,
    34              reservedDisk: 512,
    35            },
    36            {
    37              name: 'task-three',
    38              driver: 'docker',
    39              reservedMemory: 1024,
    40              reservedCPU: 1500,
    41              reservedDisk: 4096,
    42            },
    43            {
    44              name: 'task-four',
    45              driver: 'docker',
    46              reservedMemory: 2048,
    47              reservedCPU: 500,
    48              reservedDisk: 128,
    49            },
    50          ],
    51        })
    52      );
    53  
    54      assert.equal(
    55        taskGroup.get('reservedCPU'),
    56        sum(taskGroup.get('tasks'), 'reservedCPU'),
    57        'reservedCPU is an aggregate sum of task CPU reservations'
    58      );
    59      assert.equal(
    60        taskGroup.get('reservedMemory'),
    61        sum(taskGroup.get('tasks'), 'reservedMemory'),
    62        'reservedMemory is an aggregate sum of task memory reservations'
    63      );
    64      assert.equal(
    65        taskGroup.get('reservedDisk'),
    66        sum(taskGroup.get('tasks'), 'reservedDisk'),
    67        'reservedDisk is an aggregate sum of task disk reservations'
    68      );
    69    });
    70  
    71    test("should expose mergedMeta as merged with the job's meta", function (assert) {
    72      assert.expect(8);
    73  
    74      const store = this.owner.lookup('service:store');
    75  
    76      const jobWithMeta = run(() =>
    77        store.createRecord('job', {
    78          name: 'example-with-meta',
    79          meta: store.createFragment('structured-attributes', {
    80            raw: { a: 'b' },
    81          }),
    82          taskGroups: [
    83            {
    84              name: 'one',
    85              meta: { c: 'd' },
    86            },
    87            {
    88              name: 'two',
    89            },
    90            {
    91              name: 'three',
    92              meta: null,
    93            },
    94            {
    95              name: 'four',
    96              meta: {},
    97            },
    98          ],
    99        })
   100      );
   101  
   102      let expected = [{ a: 'b', c: 'd' }, { a: 'b' }, { a: 'b' }, { a: 'b' }];
   103      expected.forEach((exp, i) => {
   104        assert.deepEqual(
   105          jobWithMeta.get('taskGroups').objectAt(i).get('mergedMeta'),
   106          exp,
   107          'mergedMeta is merged with job meta'
   108        );
   109      });
   110  
   111      const jobWithoutMeta = run(() =>
   112        this.owner.lookup('service:store').createRecord('job', {
   113          name: 'example-without-meta',
   114          taskGroups: [
   115            {
   116              name: 'one',
   117              meta: { c: 'd' },
   118            },
   119            {
   120              name: 'two',
   121            },
   122            {
   123              name: 'three',
   124              meta: null,
   125            },
   126            {
   127              name: 'four',
   128              meta: {},
   129            },
   130          ],
   131        })
   132      );
   133  
   134      expected = [{ c: 'd' }, {}, {}, {}];
   135      expected.forEach((exp, i) => {
   136        assert.deepEqual(
   137          jobWithoutMeta.get('taskGroups').objectAt(i).get('mergedMeta'),
   138          exp,
   139          'mergedMeta is merged with job meta'
   140        );
   141      });
   142    });
   143  });