File Explorer

/var/runtime/node_modules/@aws-sdk/node_modules/aws-crt/lib/native
This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.
0 dirs
33 files
eventstream.spec.ts33.4 KB · 940 lines
1/*2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.3 * SPDX-License-Identifier: Apache-2.0.4 */5 6import * as eventstream from './eventstream';7import * as cancel from '../common/cancel';8import {once} from "events";9import crt_native from "./binding";10import * as os from "os";11 12jest.setTimeout(30000);13 14function hasEchoServerEnvironment() : boolean {15    if (process.env.AWS_TEST_EVENT_STREAM_ECHO_SERVER_HOST === undefined) {16        return false;17    }18 19    if (process.env.AWS_TEST_EVENT_STREAM_ECHO_SERVER_PORT === undefined) {20        return false;21    }22 23    return true;24}25 26const conditional_test = (condition : boolean) => condition ? it : it.skip;27 28function closeNativeConnectionInternal(connection: eventstream.ClientConnection) {29 30    // invoke an internal close that bypasses the binding.  The result is an invocation that simulates a network31    // disruption from the binding's perspective32    crt_native.event_stream_client_connection_close_internal(connection.native_handle());33}34 35function makeGoodConfig() : eventstream.ClientConnectionOptions {36    let config : eventstream.ClientConnectionOptions = {37        hostName: process.env.AWS_TEST_EVENT_STREAM_ECHO_SERVER_HOST ?? "",38        port: parseInt(process.env.AWS_TEST_EVENT_STREAM_ECHO_SERVER_PORT ?? "0"),39    };40 41    return config;42}43 44/*45 * successful connection setup/teardown tests include some short waits to try and shake out any native race conditions46 * that might occur due to JS object finalization after close.  For the same reason, we scope the connection object47 * to a helper function, making finalization on the extern more likely.48 */49 50conditional_test(hasEchoServerEnvironment())('Eventstream transport connection success echo server - await connect, close, and forget', async () => {51    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());52    let cancelController : cancel.CancelController = new cancel.CancelController();53 54    await connection.connect({55        cancelController : cancelController56    });57 58    // @ts-ignore59    expect(cancelController.emitter.listenerCount(cancel.EVENT_NAME)).toEqual(0);60 61    connection.close();62});63 64conditional_test(hasEchoServerEnvironment())('Eventstream transport connection success echo server - await connect, simulate remote close', async () => {65    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());66 67    let disconnected = once(connection, eventstream.ClientConnection.DISCONNECTION);68 69    await connection.connect({});70 71    // simulate a socket closed by the remote endpoint scenario72    closeNativeConnectionInternal(connection);73 74    await disconnected;75 76    await new Promise(resolve => setTimeout(resolve, 200));77 78    connection.close();79});80 81conditional_test(hasEchoServerEnvironment())('Eventstream transport connection success echo server - start connect, close, and forget', async () => {82    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());83 84    // intentionally do not await to try and beat the native connection setup with a close call85    connection.connect({});86 87    connection.close();88 89    await new Promise(resolve => setTimeout(resolve, 200));90});91 92async function doConnectionFailureTest(config : eventstream.ClientConnectionOptions) {93    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(config);94 95    let controller : cancel.CancelController = new cancel.CancelController();96 97    await expect(connection.connect({98        cancelController : controller99    })).rejects.toBeDefined();100 101    // @ts-ignore102    expect(controller.emitter.listenerCount(cancel.EVENT_NAME)).toEqual(0);103 104    connection.close();105}106 107test('Eventstream transport connection failure echo server - bad host', async () => {108    let badConfig : eventstream.ClientConnectionOptions = makeGoodConfig();109    badConfig.hostName = "localhst";110 111    await doConnectionFailureTest(badConfig);112});113 114conditional_test(hasEchoServerEnvironment())('Eventstream transport connection failure echo server - bad port', async () => {115    let badConfig : eventstream.ClientConnectionOptions = makeGoodConfig();116    badConfig.port = 33333;117 118    await doConnectionFailureTest(badConfig);119});120 121async function doProtocolConnectionSuccessTest1() {122    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());123 124    await connection.connect({});125 126    const connectResponse = once(connection, eventstream.ClientConnection.PROTOCOL_MESSAGE);127 128    let connectMessage: eventstream.Message = {129        type: eventstream.MessageType.Connect,130        headers: [131            eventstream.Header.newString(':version', '0.1.0'),132            eventstream.Header.newString('client-name', 'accepted.testy_mc_testerson')133        ]134    };135 136    await connection.sendProtocolMessage({137        message: connectMessage138    });139 140    let response : eventstream.MessageEvent = (await connectResponse)[0];141    let message : eventstream.Message = response.message;142 143    expect(message.type).toEqual(eventstream.MessageType.ConnectAck);144    expect(message.flags).toBeDefined();145    expect((message.flags ?? 0) & eventstream.MessageFlags.ConnectionAccepted).toEqual(eventstream.MessageFlags.ConnectionAccepted);146 147    connection.close();148}149 150conditional_test(hasEchoServerEnvironment())('Eventstream protocol connection success Echo Server - happy path', async () => {151    await doProtocolConnectionSuccessTest1();152 153    await new Promise(resolve => setTimeout(resolve, 200));154});155 156async function doProtocolConnectionSuccessTest2() {157    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());158 159    await connection.connect({});160 161    let connectMessage: eventstream.Message = {162        type: eventstream.MessageType.Connect,163        headers: [164            eventstream.Header.newString(':version', '0.1.0'),165            eventstream.Header.newString('client-name', 'accepted.testy_mc_testerson')166        ]167    };168 169    connection.sendProtocolMessage({170        message: connectMessage171    });172 173    connection.close();174 175    await new Promise(resolve => setTimeout(resolve, 200));176}177conditional_test(hasEchoServerEnvironment())('Eventstream protocol connection success Echo Server - close while connecting', async () => {178    await doProtocolConnectionSuccessTest2();179 180    await new Promise(resolve => setTimeout(resolve, 200));181});182 183async function makeGoodConnection() : Promise<eventstream.ClientConnection> {184    return new Promise<eventstream.ClientConnection>(async (resolve, reject) => {185        try {186            let connection: eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());187 188            await connection.connect({});189 190            const connectResponse = once(connection, eventstream.ClientConnection.PROTOCOL_MESSAGE);191 192            let connectMessage: eventstream.Message = {193                type: eventstream.MessageType.Connect,194                headers: [195                    eventstream.Header.newString(':version', '0.1.0'),196                    eventstream.Header.newString('client-name', 'accepted.testy_mc_testerson')197                ]198            };199 200            await connection.sendProtocolMessage({201                message: connectMessage202            });203 204            let response: eventstream.MessageEvent = (await connectResponse)[0];205            let message: eventstream.Message = response.message;206            if (((message.flags ?? 0) & eventstream.MessageFlags.ConnectionAccepted) == 0) {207                reject();208            }209 210            resolve(connection);211        } catch (e) {212            reject();213        }214    });215}216 217function buildAllTypeHeaderSet() : Array<eventstream.Header> {218    var encoder = new TextEncoder();219    let buffer: ArrayBuffer = encoder.encode("Some test");220    let uuid: ArrayBuffer = encoder.encode("0123456789ABCDEF");221 222    let headers: Array<eventstream.Header> = [223        eventstream.Header.newBoolean('boolTrue', true),224        eventstream.Header.newBoolean('boolFalse', false),225        eventstream.Header.newByte('byte', 8),226        eventstream.Header.newInt16('int16', 32767),227        eventstream.Header.newInt32('int32', -65537),228        eventstream.Header.newInt64FromBigint('int64Bigint', BigInt(65536) * BigInt(65536) * BigInt(2)),229        eventstream.Header.newInt64FromNumber('int64Number', 65536 * 65536 * 2),230        eventstream.Header.newInt64FromNumber('int64NumberNegative1', -1),231        eventstream.Header.newInt64FromNumber('int64NumberNegativeLarge', -123456789),232        eventstream.Header.newString('string', 'Hello'),233        eventstream.Header.newByteBuffer('binary', buffer),234        eventstream.Header.newTimeStampFromDate('date', new Date()),235        eventstream.Header.newTimeStampFromSecondsSinceEpoch('epochSeconds', Date.now()),236        eventstream.Header.newUUID('uuid', uuid)237    ];238 239    return headers;240}241 242function verifyEchoedHeaders(expectedHeaders : Array<eventstream.Header>, actualHeaders : Array<eventstream.Header>) {243    expectedHeaders.forEach((header: eventstream.Header) => {244        let actualHeader = actualHeaders.find((value: eventstream.Header) => { return value.name === header.name; });245        expect(actualHeader).toBeDefined();246 247        // @ts-ignore248        expect(header.type).toEqual(actualHeader.type);249 250        switch(header.type) {251            case eventstream.HeaderType.BooleanFalse:252            case eventstream.HeaderType.BooleanTrue:253                break;254 255            case eventstream.HeaderType.ByteBuffer:256            case eventstream.HeaderType.UUID:257            case eventstream.HeaderType.Int64:258                // @ts-ignore259                expect(Buffer.from(header.value as ArrayBuffer)).toEqual(Buffer.from(actualHeader.value as ArrayBuffer));260                break;261 262            default:263                // @ts-ignore264                expect(header.value).toEqual(actualHeader.value);265                break;266 267        }268    });269}270 271async function verifyPingRoundTrip(connection : eventstream.ClientConnection) : Promise<void> {272    return new Promise<void>(async (resolve, reject) => {273        try {274            const pingResponse = once(connection, eventstream.ClientConnection.PROTOCOL_MESSAGE);275 276            var encoder = new TextEncoder();277            let payload: ArrayBuffer = encoder.encode("A payload");278 279            let headers: Array<eventstream.Header> = buildAllTypeHeaderSet();280 281            let pingMessage: eventstream.Message = {282                type: eventstream.MessageType.Ping,283                headers: headers,284                payload: payload285            };286 287            await connection.sendProtocolMessage({288                message: pingMessage289            });290 291            let responseEvent: eventstream.MessageEvent = (await pingResponse)[0];292            let response: eventstream.Message = responseEvent.message;293 294            expect(response.type).toEqual(eventstream.MessageType.PingResponse);295            expect(response.headers).toBeDefined();296 297            verifyEchoedHeaders(headers, response.headers ?? []);298 299            expect(Buffer.from(payload)).toEqual(Buffer.from(response.payload as ArrayBuffer));300 301            resolve();302        } catch (e) {303            reject();304        }305    });306}307 308conditional_test(hasEchoServerEnvironment())('Eventstream connection success - send and receive all-header-types ping', async () => {309 310    let connection : eventstream.ClientConnection = await makeGoodConnection();311 312    await verifyPingRoundTrip(connection);313 314    connection.close();315});316 317conditional_test(hasEchoServerEnvironment())('Eventstream protocol connection failure Echo Server - bad version', async () => {318 319    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());320    await connection.connect({});321 322    const connectResponse = once(connection, eventstream.ClientConnection.PROTOCOL_MESSAGE);323    const disconnected = once(connection, eventstream.ClientConnection.DISCONNECTION);324 325    let connectMessage: eventstream.Message = {326        type: eventstream.MessageType.Connect,327        headers: [328            eventstream.Header.newString(':version', '0.0.1'),329            eventstream.Header.newString('client-name', 'accepted.testy_mc_testerson')330        ]331    };332 333    await connection.sendProtocolMessage({334        message: connectMessage335    });336 337    /*338     * Sigh.339     * On Windows, our EchoTest server closes the connection in this case with an RST rather than a FIN.  Searching340     * the web hints at a possible timing issue (that affects Windows far more than other platforms) when closing341     * server-side (listener-spawned) sockets that leads to an RST over a FIN:342     *343     *   https://github.com/libuv/libuv/issues/3034 shows a similar problem, for example.344     *345     * A socket that is closed with an RST is not readable, despite the fact that there was previously received data.346     * So we'll never be able to get the failed ConnAck because the attempt to read from the socket fails immediately.347     *348     * Alternatively, we could restrict these tests to domain/local sockets but that creates its own set of problems,349     * requiring platform-specific permissions tweaks to allow communication between multiple processes.350     *351     * So in the interest of avoiding rabbit holes, we only verify the failed connack on non-Windows platforms.352     */353    if (os.platform() !== 'win32') {354        let response: eventstream.MessageEvent = (await connectResponse)[0];355        let message: eventstream.Message = response.message;356 357        expect(message.type).toEqual(eventstream.MessageType.ConnectAck);358        expect(message.flags).toBeDefined();359        expect((message.flags ?? 0) & eventstream.MessageFlags.ConnectionAccepted).toEqual(0);360    }361 362    await disconnected;363    connection.close();364});365 366conditional_test(hasEchoServerEnvironment())('Eventstream connection failure - create with undefined', async () => {367    expect(() => {368        // @ts-ignore369        new eventstream.ClientConnection(undefined)370    }).toThrow();371});372 373conditional_test(hasEchoServerEnvironment())('Eventstream connection failure - create with missing required property', async () => {374    let config : eventstream.ClientConnectionOptions = makeGoodConfig();375 376    // @ts-ignore377    config.hostName = undefined;378 379    expect(() => {380        new eventstream.ClientConnection(config)381    }).toThrow();382});383 384conditional_test(hasEchoServerEnvironment())('Eventstream connection failure - sendProtocolMessage with undefined', async () => {385    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());386 387    await connection.connect({});388 389    // @ts-ignore390    await expect(connection.sendProtocolMessage(undefined )).rejects.toThrow();391 392    connection.close();393});394 395conditional_test(hasEchoServerEnvironment())('Eventstream connection failure - sendProtocolMessage with missing required property', async () => {396    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());397 398    await connection.connect({});399 400    let controller : cancel.CancelController = new cancel.CancelController();401 402    // @ts-ignore403    await expect(connection.sendProtocolMessage({404        cancelController: controller405    } )).rejects.toThrow();406 407    // @ts-ignore408    expect(controller.emitter.listenerCount(cancel.EVENT_NAME)).toEqual(0);409 410    connection.close();411});412 413conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - newStream while not connected', async () => {414    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());415 416    expect(() => {connection.newStream();}).toThrow();417 418    connection.close();419});420 421conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - sendProtocolMessage while not connected', async () => {422    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());423 424    let message : eventstream.Message = {425        type: eventstream.MessageType.Connect426    };427 428    await expect(connection.sendProtocolMessage({message: message} )).rejects.toThrow();429 430    connection.close();431});432 433conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - connect while connecting', async () => {434    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());435 436    let connected : Promise<void> = connection.connect({});437 438    await expect(connection.connect({})).rejects.toThrow();439 440    await connected;441 442    connection.close();443});444 445conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - connect while connected', async () => {446    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());447 448    await connection.connect({});449 450    await expect(connection.connect({})).rejects.toThrow();451 452    connection.close();453});454 455conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - connect while disconnected', async () => {456    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());457 458    let disconnected = once(connection, eventstream.ClientConnection.DISCONNECTION);459 460    await connection.connect({});461 462    // simulate a socket closed by the remote endpoint scenario463    closeNativeConnectionInternal(connection);464 465    await disconnected;466 467    await expect(connection.connect({})).rejects.toThrow();468 469    connection.close();470});471 472conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - newStream while disconnected', async () => {473    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());474 475    let disconnected = once(connection, eventstream.ClientConnection.DISCONNECTION);476 477    await connection.connect({});478 479    // simulate a socket closed by the remote endpoint scenario480    closeNativeConnectionInternal(connection);481 482    await disconnected;483 484    expect(() => {connection.newStream();}).toThrow();485 486    connection.close();487});488 489conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - sendProtocolMessage while disconnected', async () => {490    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());491 492    let disconnected = once(connection, eventstream.ClientConnection.DISCONNECTION);493 494    await connection.connect({});495 496    // simulate a socket closed by the remote endpoint scenario497    closeNativeConnectionInternal(connection);498 499    await disconnected;500 501    let message : eventstream.Message = {502        type: eventstream.MessageType.Connect503    };504 505    await expect(connection.sendProtocolMessage({message: message} )).rejects.toThrow();506 507    connection.close();508});509 510conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - connect while closed', async () => {511    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());512 513    connection.close();514 515    await expect(connection.connect({})).rejects.toThrow();516});517 518conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - newStream while closed', async () => {519    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());520 521    await connection.connect({});522 523    connection.close();524 525    expect(() => {connection.newStream();}).toThrow();526});527 528conditional_test(hasEchoServerEnvironment())('Eventstream connection state failure - sendProtocolMessage while closed', async () => {529    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());530 531    await connection.connect({});532 533    connection.close();534 535    let message : eventstream.Message = {536        type: eventstream.MessageType.Connect537    };538 539    await expect(connection.sendProtocolMessage({message: message} )).rejects.toThrow();540});541 542conditional_test(hasEchoServerEnvironment())('Eventstream stream success - create and close, no asserts', async () => {543 544    let connection : eventstream.ClientConnection = new eventstream.ClientConnection(makeGoodConfig());545 546    await connection.connect({});547 548    let stream : eventstream.ClientStream = connection.newStream();549 550    stream.close();551    connection.close();552});553 554async function openPersistentEchoStream(connection: eventstream.ClientConnection) : Promise<eventstream.ClientStream> {555    return new Promise<eventstream.ClientStream>(async (resolve, reject) => {556        try {557            let stream : eventstream.ClientStream = connection.newStream();558 559            const activateResponse = once(stream, eventstream.ClientStream.MESSAGE);560 561            let message : eventstream.Message = {562                type: eventstream.MessageType.ApplicationMessage563            };564 565            let controller : cancel.CancelController = new cancel.CancelController();566 567            await stream.activate({568                operation: "awstest#EchoStreamMessages",569                message : message,570                cancelController : controller571            });572 573            let responseEvent: eventstream.MessageEvent = (await activateResponse)[0];574            let response: eventstream.Message = responseEvent.message;575 576            expect(response.type).toEqual(eventstream.MessageType.ApplicationMessage);577 578            // @ts-ignore579            expect(controller.emitter.listenerCount(cancel.EVENT_NAME)).toEqual(0);580 581            resolve(stream);582        } catch (e) {583            reject();584        }585    });586}587conditional_test(hasEchoServerEnvironment())('Eventstream stream success - activate persistent echo stream, wait for response, close properly', async () => {588 589    let connection : eventstream.ClientConnection = await makeGoodConnection();590 591    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);592 593    stream.close();594    connection.close();595});596 597conditional_test(hasEchoServerEnvironment())('Eventstream stream success - activate persistent echo stream, wait for response, close unexpectedly, verify stream ended event', async () => {598 599    let connection : eventstream.ClientConnection = await makeGoodConnection();600 601    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);602 603    let streamEnded = once(stream, eventstream.ClientStream.ENDED);604 605    crt_native.event_stream_client_connection_close_internal(connection.native_handle());606 607    await streamEnded;608 609    stream.close();610    connection.close();611});612 613conditional_test(hasEchoServerEnvironment())('Eventstream stream success - activate one-time echo stream, verify response, verify stream ended', async () => {614 615    let connection : eventstream.ClientConnection = await makeGoodConnection();616 617    let stream : eventstream.ClientStream = connection.newStream();618 619    const activateResponse = once(stream, eventstream.ClientStream.MESSAGE);620    const streamEnded = once(stream, eventstream.ClientStream.ENDED);621 622    const payloadAsString = "{}";623 624    let message : eventstream.Message = {625        type: eventstream.MessageType.ApplicationMessage,626        payload: payloadAsString627    };628 629    await stream.activate({630        operation: "awstest#EchoMessage",631        message : message632    });633 634    let responseEvent: eventstream.MessageEvent = (await activateResponse)[0];635    let response: eventstream.Message = responseEvent.message;636 637    expect(response.type).toEqual(eventstream.MessageType.ApplicationMessage);638    expect(response.flags).toBeDefined();639    expect((response.flags ?? 0) & eventstream.MessageFlags.TerminateStream).toEqual(eventstream.MessageFlags.TerminateStream);640 641    let payload : string = "";642    if (response.payload !== undefined) {643        var decoder = new TextDecoder();644        payload = decoder.decode(Buffer.from(response.payload as ArrayBuffer));645    }646    expect(payload).toEqual(payloadAsString);647 648    await streamEnded;649 650    stream.close();651    connection.close();652});653 654conditional_test(hasEchoServerEnvironment())('Eventstream stream success - activate persistent echo stream, send message, verify echo response', async () => {655 656    let connection : eventstream.ClientConnection = await makeGoodConnection();657 658    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);659 660    const echoResponse = once(stream, eventstream.ClientStream.MESSAGE);661 662    const payloadAsString = "{}";663 664    let message : eventstream.Message = {665        type: eventstream.MessageType.ApplicationMessage,666        payload: payloadAsString667    };668 669    await stream.sendMessage({ message : message });670 671    let responseEvent: eventstream.MessageEvent = (await echoResponse)[0];672    let response: eventstream.Message = responseEvent.message;673 674    expect(response.type).toEqual(eventstream.MessageType.ApplicationMessage);675    expect((response.flags ?? 0) & eventstream.MessageFlags.TerminateStream).toEqual(0);676 677    let payload : string = "";678    if (response.payload !== undefined) {679        var decoder = new TextDecoder();680        payload = decoder.decode(Buffer.from(response.payload as ArrayBuffer));681    }682    expect(payload).toEqual(payloadAsString);683 684    stream.close();685    connection.close();686});687 688conditional_test(hasEchoServerEnvironment())('Eventstream stream success - client-side terminate a persistent echo stream', async () => {689 690    let connection : eventstream.ClientConnection = await makeGoodConnection();691    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);692 693    const streamEnded = once(stream, eventstream.ClientStream.ENDED);694 695    let message : eventstream.Message = {696        type: eventstream.MessageType.ApplicationMessage,697        flags: eventstream.MessageFlags.TerminateStream698    };699 700    await stream.sendMessage({ message : message });701 702    await streamEnded;703 704    stream.close();705    connection.close();706});707 708conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - activate invalid operation', async () => {709 710    let connection : eventstream.ClientConnection = await makeGoodConnection();711    let stream : eventstream.ClientStream = connection.newStream();712 713    const streamEnded = once(stream, eventstream.ClientStream.ENDED);714    const activateResponse = once(stream, eventstream.ClientStream.MESSAGE);715 716    const payloadAsString = "{}";717 718    let message : eventstream.Message = {719        type: eventstream.MessageType.ApplicationMessage,720        payload: payloadAsString721    };722 723    await stream.activate({724        operation: "awstest#NotAValidOperation",725        message : message726    });727 728    let responseEvent: eventstream.MessageEvent = (await activateResponse)[0];729    let response: eventstream.Message = responseEvent.message;730 731    expect(response.type).toEqual(eventstream.MessageType.ApplicationError);732 733    await streamEnded;734 735    stream.close();736    connection.close();737});738 739conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - send invalid payload', async () => {740 741    let connection : eventstream.ClientConnection = await makeGoodConnection();742    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);743 744    const streamEnded = once(stream, eventstream.ClientStream.ENDED);745    const echoResponse = once(stream, eventstream.ClientStream.MESSAGE);746 747    let message : eventstream.Message = {748        type: eventstream.MessageType.ApplicationMessage,749        payload: "}"750    };751 752    await stream.sendMessage({ message : message });753 754    let responseEvent: eventstream.MessageEvent = (await echoResponse)[0];755    let response: eventstream.Message = responseEvent.message;756 757    expect(response.type).toEqual(eventstream.MessageType.ApplicationError);758 759    await streamEnded;760 761    stream.close();762    connection.close();763});764 765conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - send message on unactivated stream', async () => {766 767    let connection : eventstream.ClientConnection = await makeGoodConnection();768    let stream : eventstream.ClientStream = connection.newStream();769 770    let message : eventstream.Message = {771        type: eventstream.MessageType.ApplicationMessage772    };773 774    await expect(stream.sendMessage({message: message} )).rejects.toThrow();775 776    stream.close();777    connection.close();778});779 780conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - double activate stream', async () => {781 782    let connection : eventstream.ClientConnection = await makeGoodConnection();783    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);784 785    let message : eventstream.Message = {786        type: eventstream.MessageType.ApplicationMessage787    };788 789    await expect(stream.activate({operation: "awstest#EchoStreamMessages", message: message} )).rejects.toThrow();790 791    stream.close();792    connection.close();793});794 795conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - send message on ended stream', async () => {796 797    let connection : eventstream.ClientConnection = await makeGoodConnection();798    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);799 800    const streamEnded = once(stream, eventstream.ClientStream.ENDED);801 802    let message : eventstream.Message = {803        type: eventstream.MessageType.ApplicationMessage,804        flags: eventstream.MessageFlags.TerminateStream805    };806 807    await stream.sendMessage({ message : message });808 809    await streamEnded;810 811    await expect(stream.sendMessage({message: message} )).rejects.toThrow();812 813    stream.close();814    connection.close();815});816 817conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - activate a closed stream', async () => {818 819    let connection : eventstream.ClientConnection = await makeGoodConnection();820    let stream : eventstream.ClientStream = connection.newStream();821 822    stream.close();823 824    let message : eventstream.Message = {825        type: eventstream.MessageType.ApplicationMessage826    };827 828    await expect(stream.activate({operation: "awstest#EchoStreamMessages", message: message} )).rejects.toThrow();829 830    connection.close();831});832 833conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - send message on a closed stream', async () => {834 835    let connection : eventstream.ClientConnection = await makeGoodConnection();836    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);837 838    stream.close();839 840    let message : eventstream.Message = {841        type: eventstream.MessageType.ApplicationMessage842    };843 844    await expect(stream.sendMessage({message: message} )).rejects.toThrow();845 846    connection.close();847});848 849conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - activate with undefined', async () => {850    let connection : eventstream.ClientConnection = await makeGoodConnection();851    let stream : eventstream.ClientStream = connection.newStream();852 853    // @ts-ignore854    await expect(stream.activate(undefined)).rejects.toThrow();855 856    stream.close();857    connection.close();858});859 860conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - activate with missing required property', async () => {861    let connection : eventstream.ClientConnection = await makeGoodConnection();862    let stream : eventstream.ClientStream = connection.newStream();863 864    let controller : cancel.CancelController = new cancel.CancelController();865 866    // @ts-ignore867    let activateOptions : eventstream.ActivateStreamOptions = {868        message: {869            type: eventstream.MessageType.ApplicationMessage870        },871        cancelController: controller872    }873    await expect(stream.activate(activateOptions)).rejects.toThrow();874 875    // @ts-ignore876    expect(controller.emitter.listenerCount(cancel.EVENT_NAME)).toEqual(0);877 878    stream.close();879    connection.close();880});881 882conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - sendMessage with undefined', async () => {883    let connection : eventstream.ClientConnection = await makeGoodConnection();884    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);885 886    // @ts-ignore887    await expect(stream.sendMessage(undefined)).rejects.toThrow();888 889    stream.close();890    connection.close();891});892 893conditional_test(hasEchoServerEnvironment())('Eventstream stream failure - sendMessage with missing required property', async () => {894    let connection : eventstream.ClientConnection = await makeGoodConnection();895    let stream : eventstream.ClientStream = await openPersistentEchoStream(connection);896    let controller : cancel.CancelController = new cancel.CancelController();897 898    // @ts-ignore899    await expect(stream.sendMessage({900        cancelController: controller901    })).rejects.toThrow();902 903    // @ts-ignore904    expect(controller.emitter.listenerCount(cancel.EVENT_NAME)).toEqual(0);905 906    stream.close();907    connection.close();908});909 910conditional_test(process.platform !== 'win32')('Eventstream connection cancel - example.com, cancel after connect', async () => {911    // Connection to example.com hangs atm on all platforms except Windows912    let connection: eventstream.ClientConnection = new eventstream.ClientConnection({913        hostName: "example.com",914        port: 22915    });916 917    let controller : cancel.CancelController = new cancel.CancelController();918 919    setTimeout(() => { controller.cancel(); }, 1000);920 921    await expect(connection.connect({922        cancelController : controller923    })).rejects.toThrow("cancelled");924});925 926test('Eventstream connection cancel - example.com, cancel before connect', async () => {927    // Connection to example.com hangs atm on all platforms except Windows928    let connection: eventstream.ClientConnection = new eventstream.ClientConnection({929        hostName: "example.com",930        port: 22931    });932 933    let controller : cancel.CancelController = new cancel.CancelController();934    controller.cancel();935    936    await expect(connection.connect({937        cancelController : controller938    })).rejects.toThrow("cancelled");939});940