github.com/hernad/nomad@v1.6.112/ui/tests/integration/util/exec-socket-xterm-adapter-test.js (about)

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