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

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