github.com/anth0d/nomad@v0.0.0-20221214183521-ae3a0a2cad06/ui/tests/integration/util/exec-socket-xterm-adapter-test.js (about)

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