github.com/ferranbt/nomad@v0.9.3-0.20190607002617-85c449b7667c/ui/tests/unit/serializers/node-test.js (about)

     1  import { module, test } from 'qunit';
     2  import { setupTest } from 'ember-qunit';
     3  import { run } from '@ember/runloop';
     4  import NodeModel from 'nomad-ui/models/node';
     5  import pushPayloadToStore from '../../utils/push-payload-to-store';
     6  import { settled } from '@ember/test-helpers';
     7  
     8  module('Unit | Serializer | Node', function(hooks) {
     9    setupTest(hooks);
    10    hooks.beforeEach(function() {
    11      this.store = this.owner.lookup('service:store');
    12      this.subject = () => this.store.serializerFor('node');
    13    });
    14  
    15    test('local store is culled to reflect the state of findAll requests', async function(assert) {
    16      const findAllResponse = [
    17        makeNode('1', 'One', '127.0.0.1:4646'),
    18        makeNode('2', 'Two', '127.0.0.2:4646'),
    19        makeNode('3', 'Three', '127.0.0.3:4646'),
    20      ];
    21  
    22      const payload = this.subject().normalizeFindAllResponse(this.store, NodeModel, findAllResponse);
    23      pushPayloadToStore(this.store, payload, NodeModel.modelName);
    24  
    25      assert.equal(
    26        payload.data.length,
    27        findAllResponse.length,
    28        'Each original record is returned in the response'
    29      );
    30  
    31      assert.equal(
    32        this.store
    33          .peekAll('node')
    34          .filterBy('id')
    35          .get('length'),
    36        findAllResponse.length,
    37        'Each original record is now in the store'
    38      );
    39  
    40      const newFindAllResponse = [
    41        makeNode('2', 'Two', '127.0.0.2:4646'),
    42        makeNode('3', 'Three', '127.0.0.3:4646'),
    43        makeNode('4', 'Four', '127.0.0.4:4646'),
    44      ];
    45  
    46      let newPayload;
    47      run(() => {
    48        newPayload = this.subject().normalizeFindAllResponse(
    49          this.store,
    50          NodeModel,
    51          newFindAllResponse
    52        );
    53      });
    54      pushPayloadToStore(this.store, newPayload, NodeModel.modelName);
    55  
    56      await settled();
    57      assert.equal(
    58        newPayload.data.length,
    59        newFindAllResponse.length,
    60        'Each new record is returned in the response'
    61      );
    62  
    63      assert.equal(
    64        this.store
    65          .peekAll('node')
    66          .filterBy('id')
    67          .get('length'),
    68        newFindAllResponse.length,
    69        'The node length in the store reflects the new response'
    70      );
    71  
    72      assert.notOk(this.store.peekAll('node').findBy('id', '1'), 'Record One is no longer found');
    73    });
    74  
    75    function makeNode(id, name, ip) {
    76      return { ID: id, Name: name, HTTPAddr: ip };
    77    }
    78  
    79    const normalizationTestCases = [
    80      {
    81        name: 'Normal',
    82        in: {
    83          ID: 'test-node',
    84          HTTPAddr: '867.53.0.9:4646',
    85          Drain: false,
    86          Drivers: {
    87            docker: {
    88              Detected: true,
    89              Healthy: false,
    90            },
    91          },
    92        },
    93        out: {
    94          data: {
    95            id: 'test-node',
    96            type: 'node',
    97            attributes: {
    98              isDraining: false,
    99              httpAddr: '867.53.0.9:4646',
   100              drivers: [
   101                {
   102                  name: 'docker',
   103                  detected: true,
   104                  healthy: false,
   105                },
   106              ],
   107            },
   108            relationships: {
   109              allocations: {
   110                links: {
   111                  related: '/v1/node/test-node/allocations',
   112                },
   113              },
   114            },
   115          },
   116        },
   117      },
   118  
   119      {
   120        name: 'Dots in driver names',
   121        in: {
   122          ID: 'test-node',
   123          HTTPAddr: '867.53.0.9:4646',
   124          Drain: false,
   125          Drivers: {
   126            'my.driver': {
   127              Detected: true,
   128              Healthy: false,
   129            },
   130            'my.other.driver': {
   131              Detected: false,
   132              Healthy: false,
   133            },
   134          },
   135        },
   136        out: {
   137          data: {
   138            id: 'test-node',
   139            type: 'node',
   140            attributes: {
   141              isDraining: false,
   142              httpAddr: '867.53.0.9:4646',
   143              drivers: [
   144                {
   145                  name: 'my.driver',
   146                  detected: true,
   147                  healthy: false,
   148                },
   149                {
   150                  name: 'my.other.driver',
   151                  detected: false,
   152                  healthy: false,
   153                },
   154              ],
   155            },
   156            relationships: {
   157              allocations: {
   158                links: {
   159                  related: '/v1/node/test-node/allocations',
   160                },
   161              },
   162            },
   163          },
   164        },
   165      },
   166    ];
   167  
   168    normalizationTestCases.forEach(testCase => {
   169      test(`normalization: ${testCase.name}`, async function(assert) {
   170        assert.deepEqual(this.subject().normalize(NodeModel, testCase.in), testCase.out);
   171      });
   172    });
   173  });