github.com/Ilhicas/nomad@v1.0.4-0.20210304152020-e86851182bc3/ui/tests/integration/util/exec-socket-xterm-adapter-test.js (about)

     1  import ExecSocketXtermAdapter from 'nomad-ui/utils/classes/exec-socket-xterm-adapter';
     2  import { setupRenderingTest } from 'ember-qunit';
     3  import { module, test } from 'qunit';
     4  import { render, settled } from '@ember/test-helpers';
     5  import hbs from 'htmlbars-inline-precompile';
     6  import { Terminal } from 'xterm';
     7  import { HEARTBEAT_INTERVAL } from 'nomad-ui/utils/classes/exec-socket-xterm-adapter';
     8  import sinon from 'sinon';
     9  
    10  module('Integration | Utility | exec-socket-xterm-adapter', function(hooks) {
    11    setupRenderingTest(hooks);
    12  
    13    test('initiating socket sends authentication handshake', async function(assert) {
    14      let done = assert.async();
    15  
    16      let terminal = new Terminal();
    17      this.set('terminal', terminal);
    18  
    19      await render(hbs`
    20        <ExecTerminal @terminal={{terminal}} />
    21      `);
    22  
    23      await settled();
    24  
    25      let firstMessage = true;
    26      let mockSocket = new Object({
    27        send(message) {
    28          if (firstMessage) {
    29            firstMessage = false;
    30            assert.deepEqual(message, JSON.stringify({ version: 1, auth_token: 'mysecrettoken' }));
    31            mockSocket.onclose();
    32            done();
    33          }
    34        },
    35      });
    36  
    37      new ExecSocketXtermAdapter(terminal, mockSocket, 'mysecrettoken');
    38  
    39      mockSocket.onopen();
    40  
    41      await settled();
    42    });
    43  
    44    test('initiating socket sends authentication handshake even if unauthenticated', async function(assert) {
    45      let done = assert.async();
    46  
    47      let terminal = new Terminal();
    48      this.set('terminal', terminal);
    49  
    50      await render(hbs`
    51        <ExecTerminal @terminal={{terminal}} />
    52      `);
    53  
    54      await settled();
    55  
    56      let firstMessage = true;
    57      let mockSocket = new Object({
    58        send(message) {
    59          if (firstMessage) {
    60            firstMessage = false;
    61            assert.deepEqual(message, JSON.stringify({ version: 1, auth_token: '' }));
    62            mockSocket.onclose();
    63            done();
    64          }
    65        },
    66      });
    67  
    68      new ExecSocketXtermAdapter(terminal, mockSocket, null);
    69  
    70      mockSocket.onopen();
    71  
    72      await settled();
    73    });
    74  
    75    test('a heartbeat is sent periodically', async function(assert) {
    76      let done = assert.async();
    77  
    78      const clock = sinon.useFakeTimers({
    79        now: new Date(),
    80        shouldAdvanceTime: true,
    81      });
    82  
    83      let terminal = new Terminal();
    84      this.set('terminal', terminal);
    85  
    86      await render(hbs`
    87        <ExecTerminal @terminal={{terminal}} />
    88      `);
    89  
    90      await settled();
    91  
    92      let mockSocket = new Object({
    93        send(message) {
    94          if (!message.includes('version') && !message.includes('tty_size')) {
    95            assert.deepEqual(message, JSON.stringify({}));
    96            clock.restore();
    97            mockSocket.onclose();
    98            done();
    99          }
   100        },
   101      });
   102  
   103      new ExecSocketXtermAdapter(terminal, mockSocket, null);
   104      mockSocket.onopen();
   105      await settled();
   106      clock.tick(HEARTBEAT_INTERVAL);
   107    });
   108  
   109    test('resizing the window passes a resize message through the socket', async function(assert) {
   110      let done = assert.async();
   111  
   112      let terminal = new Terminal();
   113      this.set('terminal', terminal);
   114  
   115      await render(hbs`
   116        <ExecTerminal @terminal={{terminal}} />
   117      `);
   118  
   119      await settled();
   120  
   121      let mockSocket = new Object({
   122        send(message) {
   123          assert.deepEqual(
   124            message,
   125            JSON.stringify({ tty_size: { width: terminal.cols, height: terminal.rows } })
   126          );
   127          mockSocket.onclose();
   128          done();
   129        },
   130      });
   131  
   132      new ExecSocketXtermAdapter(terminal, mockSocket, '');
   133  
   134      window.dispatchEvent(new Event('resize'));
   135  
   136      await settled();
   137    });
   138  
   139    test('stdout frames without data are ignored', async function(assert) {
   140      assert.expect(0);
   141  
   142      let terminal = new Terminal();
   143      this.set('terminal', terminal);
   144  
   145      await render(hbs`
   146        <ExecTerminal @terminal={{terminal}} />
   147      `);
   148  
   149      await settled();
   150  
   151      let mockSocket = new Object({
   152        send() {},
   153      });
   154  
   155      new ExecSocketXtermAdapter(terminal, mockSocket, '');
   156  
   157      mockSocket.onmessage({
   158        data: '{"stdout":{"exited":"true"}}',
   159      });
   160  
   161      await settled();
   162      mockSocket.onclose();
   163    });
   164  
   165    test('stderr frames are ignored', async function(assert) {
   166      let terminal = new Terminal();
   167      this.set('terminal', terminal);
   168  
   169      await render(hbs`
   170        <ExecTerminal @terminal={{terminal}} />
   171      `);
   172  
   173      await settled();
   174  
   175      let mockSocket = new Object({
   176        send() {},
   177      });
   178  
   179      new ExecSocketXtermAdapter(terminal, mockSocket, '');
   180  
   181      mockSocket.onmessage({
   182        data: '{"stdout":{"data":"c2gtMy4yIPCfpbMk"}}',
   183      });
   184  
   185      mockSocket.onmessage({
   186        data: '{"stderr":{"data":"c2gtMy4yIPCfpbMk"}}',
   187      });
   188  
   189      await settled();
   190  
   191      assert.equal(
   192        terminal.buffer.active
   193          .getLine(0)
   194          .translateToString()
   195          .trim(),
   196        'sh-3.2 🥳$'
   197      );
   198  
   199      mockSocket.onclose();
   200    });
   201  });