@servicenow/sdk-build-plugins 2.0.1

package/dist/atf/ATFComposer.d.ts

@@ -0,0 +1,492 @@
+import { Data, Record, TableName } from '@servicenow/sdk-core/runtime/db';
+import type { Role } from '@servicenow/sdk-core/runtime/app';
+import { Context, InputObject } from '@servicenow/sdk-build-core';
+import * as atf from '@servicenow/sdk-core/runtime/atf';
+export declare function getRecordIdIfRecord(value: any, context: Context): string;
+export declare function getRoleId(record: Role, context: Context): string;
+export declare function getRecordId<T extends TableName>(record: Record<T>, context: Context): string;
+export declare function isRecord(value: any): value is Record;
+export declare function isRole(value: any): value is Role;
+/**
+ * These functions will return record lists instead of the return type property specified in the interface. Hence the explicit any return
+ *
+ */
+export declare class ATF implements atf.FlatATF {
+    test: Record<'sys_atf_test'>;
+    /**
+     * Do not modify directly. Let TestPlugin handle incrementing the value
+     */
+    private order;
+    /**
+     * Do not manipulate directly in step functions. Instead create helper creation functions that increment this value
+     *
+     * Modified in the following locations:
+     * ```typescript
+     * function createStepRecord
+     * function _createGemRecords
+     * function _createVariableValueRecord
+     * ```
+     */
+    _records: {
+        [stepRecord: string]: Record[];
+    };
+    /**
+     * Used to access previously created steps based on index. Do not manipulate directly unless you are sure of what you are doing
+     *
+     * Modified in the following locations:
+     * ```typescript
+     * createStepRecord
+     * ```
+     */
+    stepRecords: Record<'sys_atf_step'>[];
+    private context;
+    constructor(inputObject: InputObject & {
+        name: string;
+        description: string;
+        active: boolean;
+        failOnServerError: boolean;
+    }, context: Context);
+    /**
+     * DO NOT CALL DIRECTLY
+     * Unless you know what you are doing do not handle setting the order number. It is handled by TestPlugin
+     */
+    incrementOrder(): void;
+    private parseValue;
+    private isTemplateStr;
+    /**
+     * Determines if gem is used at all in this value or down the nested object. If gem is used it is required to use sys_element_mapping in addition to sys_variable_value
+     */
+    private containsGem;
+    /**
+     *
+     * @param value Any value
+     * @returns whether the value is a gem mapping from an output variable
+     */
+    private isGem;
+    private createStepRecord;
+    /**
+     * All records: test, step, or metadata, which are necessary for the test
+     */
+    get records(): {
+        [stepRecord: string]: Record[];
+    };
+    private _createGemRecords;
+    /**
+     * Use createVariable instead unless you have good reason to use this
+     * @param props
+     * @returns
+     */
+    private _createVariableValueRecord;
+    private fieldValuesToQuery;
+    private recordListToString;
+    /**
+     * Outputs a string value which is either standard_ui or the sys_id of the form view
+     */
+    private parseFormUI;
+    private extractSysIdIfRecord;
+    private secondsToDuration;
+    private nameValuePairProcessing;
+    private createVariable;
+    openExistingRecord(inputs: {
+        formUI: atf.FormUIType;
+        view: string;
+        recordId: string | Record;
+        table: TableName;
+        selectedTabIndex: number;
+    }): void;
+    openNewForm(inputs: {
+        table: TableName;
+        view: string;
+        formUI: atf.FormUIType;
+    }): void;
+    fieldValueValidation<T extends TableName>(inputs: {
+        table: T;
+        conditions: string;
+        formUI: atf.FormUIType;
+    }): void;
+    setFieldValue<T extends TableName>(inputs: {
+        table: T;
+        fieldValues: Partial<Data<T>>;
+        formUI: atf.FormUIType;
+    }): void;
+    submitForm(inputs: {
+        assertType: atf.AssertType;
+        formUI: atf.FormUIType;
+    }): any;
+    validateOutboundEmailGeneratedByNotification(inputs: {
+        sourceNotification: string | Record<'sysevent_email_action'>;
+        conditions: string;
+    }): any;
+    recordUpdate<T extends TableName>(inputs: {
+        assertType: atf.AssertUpdateType;
+        enforceSecurity: boolean;
+        table: T;
+        recordId: string | Record<T>;
+        fieldValues: Partial<Data<T>>;
+    }): any;
+    generateRandomString(inputs: {
+        length: number;
+    }): any;
+    uiActionVisibility<T extends TableName>(inputs: {
+        formUI: atf.FormUIType;
+        table: T;
+        visible: (string | Record<'sys_ui_action'>)[];
+        notVisible: (string | Record<'sys_ui_action'>)[];
+    }): any;
+    validatePriceAndRecurringPrice(inputs: {
+        price: string | number;
+        recurringPrice: string | number;
+        frequency: atf.FrequencyType;
+    }): any;
+    assertResponseJSONPayloadIsValid(inputs: {
+        [name: string]: never;
+    }): any;
+    clickModalButton(inputs: {
+        formUI: atf.FormUIType;
+        uiPage: string | Record<'sys_ui_page'>;
+        assertType: atf.AssertModalType;
+        button: string;
+        assertTimeout: number;
+    }): any;
+    addItemToShoppingCart(inputs: {
+        assert: atf.AssertShoppingType;
+    }): any;
+    moduleVisibility(inputs: {
+        navigator: atf.NavigatorType;
+        assertNotVisible: atf.AssertModuleNotVisibleType;
+        notVisibleModules: (string | Record<'sys_app_module'>)[];
+        assertVisible: atf.AssertModuleVisibleType;
+        visibleModules: (string | Record<'sys_app_module'>)[];
+    }): any;
+    impersonate(inputs: {
+        user: string | Record<'sys_user'>;
+    }): any;
+    openRecordProducer(inputs: {
+        catalogItem: string | Record<'sc_cat_item_producer'>;
+    }): any;
+    recordValidation<T extends TableName>(inputs: {
+        enforceSecurity: boolean;
+        assertType: atf.AssertRecordValidationType;
+        table: T;
+        recordId: string | Record;
+        fieldValues: string;
+    }): any;
+    setCatalogItemQuantity(inputs: {
+        quantity: number | string;
+    }): any;
+    orderCatalogItem(inputs: {
+        assertType: atf.AssertOrderCatalogItemType;
+    }): any;
+    clickDeclarativeAction<T extends TableName>(inputs: {
+        formUI: atf.FormUIType;
+        table: T;
+        declarativeAction: string | Record<'sys_declarative_action_assignment'>;
+        assertType: atf.AssertDeclarativeActionType;
+    }): any;
+    assertXMLResponsePayloadElement(inputs: {
+        elementPath: string;
+        responseOperation: atf.ResponseValueOperationType;
+        elementValue: string;
+    }): any;
+    responsiveDashboardVisibility(inputs: {
+        dashboard: string | Record<'pa_dashboards'>;
+        assertType: atf.AssertResponsiveDashboardType;
+    }): any;
+    generateInboundReplyEmail<T extends TableName>(inputs: {
+        targetRecord: string | Record<T>;
+        subject: string;
+        body: string;
+        targetTable: T;
+        from: string;
+        to: string;
+    }): any;
+    assertStatusCodeName(inputs: {
+        responseOperation: atf.ResponseOperationValueType;
+        codeName: string;
+    }): any;
+    clickUIAction(inputs: {
+        formUI: atf.FormUIType;
+        table: TableName;
+        actionType: atf.UIActionType;
+        declarativeAction: string | Record<'sys_declarative_action_assignment'>;
+        uiAction: string | Record<'sys_ui_action'>;
+        assertType: atf.UIActionAssertType;
+    }): any;
+    createUser(inputs: {
+        fieldValues: Partial<Data<'sys_user'>>;
+        groups: (string | Record<'sys_user_group'>)[];
+        roles: (string | Role)[];
+        impersonate: boolean;
+        firstName: string;
+        lastName: string;
+    }): any;
+    recordDelete<T extends TableName>(inputs: {
+        enforceSecurity: boolean;
+        assertType: atf.RecordDeleteAssertType;
+        table: T;
+        recordId: string | Record<T>;
+    }): any;
+    openCatalogItem(inputs: {
+        catalogItem: string | Record<'sc_cat_item'>;
+    }): any;
+    setVariableValue(inputs: {
+        catalogItem: string | Record<'sc_cat_item'> | Record<'sc_cat_item_producer'>;
+        variableValues: string;
+    }): any;
+    sendRestRequest(inputs: {
+        basicAuthentication: string | Record<'sys_auth_profile_basic'>;
+        method: atf.HTTPMethodType;
+        path: string;
+        queryParameters: atf.QueryParam;
+        headers: {
+            [name: string]: string | number | boolean;
+        };
+        body: string;
+    }): any;
+    assertStatusCode(inputs: {
+        operation: atf.RestStatusOperationType;
+        statusCode: number;
+    }): void;
+    assertResponseXMLPayloadIsWellFormed(inputs: {
+        [name: string]: never;
+    }): void;
+    responsiveDashboardSharing(inputs: {
+        dashboard: string | Record<'pa_dashboards'>;
+        assertType: atf.DashboardSharingAssertType;
+    }): void;
+    log(inputs: {
+        log: string;
+    }): void;
+    declarativeActionVisibility(inputs: {
+        formUI: atf.FormUIType;
+        table: TableName;
+        visible: (string | Record<'sys_declarative_action_assignment'>)[];
+        notVisible: (string | Record<'sys_declarative_action_assignment'>)[];
+    }): void;
+    navigateToModule(inputs: {
+        module: string | Record<'sys_app_module'>;
+    }): void;
+    applicationMenuVisibility(inputs: {
+        navigator: atf.NavigatorType;
+        visible: (string | Record<'sys_app_application'>)[];
+        assertVisible: atf.AssertApplicationVisibleType;
+        notVisible: (string | Record<'sys_app_application'>)[];
+        assertNotVisible: atf.AssertApplicationNotVisibleType;
+    }): void;
+    checkoutShoppingCart(inputs: {
+        assert: atf.AssertCartType;
+        requestedFor: string | Record<'sys_user'>;
+        deliveryAddress: string;
+        specialInstructions: string;
+    }): any;
+    submitRecordProducer(inputs: {
+        assert: atf.AssertProducerType;
+    }): any;
+    openRecordProducer_SP(inputs: {
+        portal: string | Record<'sp_portal'>;
+        page: string | Record<'sp_page'>;
+        recordProducer: string | Record<'sc_cat_item_producer'>;
+        queryParameters: atf.QueryParam;
+    }): void;
+    openOrderGuide_SP(inputs: {
+        portal: string | Record<'sp_portal'>;
+        page: string | Record<'sp_page'>;
+        orderGuide: string | Record<'sc_cat_item_guide'>;
+        queryParameters: atf.QueryParam;
+    }): any;
+    openForm_SP<T extends TableName>(inputs: {
+        portal: string | Record<'sp_portal'>;
+        page: string | Record<'sp_page'>;
+        table: T;
+        paramID: string | Record<T>;
+        view: string;
+        queryParameters: atf.QueryParam;
+    }): void;
+    openCatalogItem_SP(inputs: {
+        portal: string | Record<'sp_portal'>;
+        page: string | Record<'sp_page'>;
+        catItem: string | Record<'sc_cat_item'>;
+        queryParameters: atf.QueryParam;
+    }): void;
+    saveCurrentRowOfMultiRowVariableSet_SP(inputs: {
+        assert: atf.AssertMultiRowType;
+    }): void;
+    addRowToMultiRowVariableSet_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'>;
+        variableSet: string | Record<'item_option_new_set'>;
+    }): void;
+    fieldStateValidation<T extends TableName>(inputs: {
+        formUI: atf.FormUIType;
+        table: T;
+        visible: (keyof Data<T> | atf.SomeOtherString)[];
+        notVisible: (keyof Data<T> | atf.SomeOtherString)[];
+        readOnly: (keyof Data<T> | atf.SomeOtherString)[];
+        notReadOnly: (keyof Data<T> | atf.SomeOtherString)[];
+        mandatory: (keyof Data<T> | atf.SomeOtherString)[];
+        notMandatory: (keyof Data<T> | atf.SomeOtherString)[];
+    }): void;
+    validateOutboundEmailGeneratedByFlow(inputs: {
+        sourceFlow: string | Record<'sys_hub_flow'>;
+        conditions: string;
+    }): void;
+    reportVisibility(inputs: {
+        report: string | Record<'sys_report'>;
+        assertType: atf.AssertReportVisibilityType;
+    }): void;
+    openServicePortalPage(inputs: {
+        portal: string | Record<'sp_portal'>;
+        page: string | Record<'sp_page'>;
+        queryParams: atf.QueryParam;
+    }): void;
+    recordQuery<T extends TableName>(inputs: {
+        enforceSecurity: boolean;
+        assertType: atf.AssertQueryType;
+        table: T;
+        fieldValues: string;
+    }): any;
+    generateInboundEmail(inputs: {
+        from: string;
+        to: string;
+        subject: string;
+        body: string;
+    }): any;
+    validateVariableValue(inputs: {
+        catalogItem: Record<'sc_cat_item'>;
+        catalogConditions: string;
+    }): void;
+    assertResponseTime(inputs: {
+        responseOperation: atf.ResponseConditionOperationType;
+        responseTime: number;
+    }): any;
+    assertJsonResponsePayloadElement(inputs: {
+        elementName: string;
+        operation: atf.AssertResponseOperationType;
+        elementValue: string;
+    }): any;
+    setVariableValue_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'> | Record<'sc_cat_item_producer'>;
+        variableSet: string | Record<'item_option_new_set'>;
+        variableValues: string;
+    }): void;
+    validateVariableValue_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'>;
+        variableSet: string | Record<'item_option_new_set'>;
+        variableValues: string;
+    }): void;
+    variableStateValidation_SP(inputs: {
+        catItem: string | Record<'sc_cat_item'>;
+        variableSet: string | Record<'item_option_new_set'>;
+        visible: string[];
+        notVisible: string[];
+        readonly: string[];
+        notReadonly: string[];
+        mandatory: string[];
+        notMandatory: string[];
+    }): void;
+    validatePriceAndRecurringPrice_SP(inputs: {
+        price: string | number;
+        recurringPrice: string | number;
+        frequency: atf.FrequencyType;
+    }): void;
+    navigatewithinOrderGuide_SP(inputs: {
+        guideStep: atf.GuideStepType;
+        assert: atf.AssertNavigate;
+    }): void;
+    setFieldValue_SP<T extends TableName>(inputs: {
+        table: T;
+        fieldValues: Partial<Data<T>>;
+    }): void;
+    setCatalogItemQuantity_SP(inputs: {
+        quantity: string | number;
+    }): void;
+    validateOrderGuideItem_SP(inputs: {
+        items: (string | Record<'sc_cat_item'>)[];
+    }): void;
+    reviewOrderGuideSummary_SP(inputs: {
+        items: (string | Record<'sc_cat_item'>)[];
+        price: string | number;
+    }): void;
+    fieldValueValidation_SP<T extends TableName>(inputs: {
+        table: T;
+        conditions: string;
+    }): void;
+    fieldStateValidation_SP<T extends TableName>(inputs: {
+        table: T;
+        visible: (keyof Data<T> | atf.SomeOtherString)[];
+        notVisible: (keyof Data<T> | atf.SomeOtherString)[];
+        mandatory: (keyof Data<T> | atf.SomeOtherString)[];
+        notMandatory: (keyof Data<T> | atf.SomeOtherString)[];
+        readonly: (keyof Data<T> | atf.SomeOtherString)[];
+        notReadonly: (keyof Data<T> | atf.SomeOtherString)[];
+    }): void;
+    uiActionVisibilityValidation_SP<T extends TableName>(inputs: {
+        table: T;
+        visible: (string | Record<'sys_ui_action'>)[];
+        notVisible: (string | Record<'sys_ui_action'>)[];
+    }): void;
+    reviewIteminOrderGuide_SP(inputs: {
+        item: string | Record<'sc_cat_item'>;
+        included: boolean;
+    }): void;
+    clickUIAction_SP<T extends TableName>(inputs: {
+        table: T;
+        uiAction: string | Record<'sys_ui_action'>;
+        assert: atf.AssertClickUIActionSP;
+    }): any;
+    submitForm_SP(inputs: {
+        assert: atf.AssertSubmitFormSP;
+    }): any;
+    addItemtoShoppingCart_SP(inputs: {
+        assert: atf.AssertAddItemToCartSP;
+    }): any;
+    addOrderGuidetoShoppingCart_SP(inputs: {
+        assert: atf.AssertAddOrderGuidetoShoppingCart_SP;
+    }): void;
+    submitOrderGuide_SP(inputs: {
+        assert: atf.AssertSubmitOrderGuideSP;
+    }): any;
+    submitRecordProducer_SP(inputs: {
+        assert: atf.AssertRecordProducerSubmitSP;
+    }): any;
+    orderCatalogItem_SP(inputs: {
+        assert: atf.AssertOrderCatalogItemSP;
+    }): any;
+    validateOutboundEmail(inputs: {
+        conditions: string;
+    }): void;
+    recordInsert<T extends TableName>(inputs: {
+        assertType: atf.AssertInsert;
+        enforceSecurity: boolean;
+        table: T;
+        fieldValues: Partial<Data<T>>;
+    }): any;
+    searchForCatalogItem(inputs: {
+        search_in_portal: boolean;
+        search_term: string;
+        catalog: string | Record<'sc_catalog'>;
+        category: string | Record<'sc_category'>;
+        assert_item: string | Record<'sc_cat_item'>;
+        assert_type: atf.AssertCatalogItem;
+    }): any;
+    replayRequestItem(inputs: {
+        request_item: string | Record<'sc_req_item'>;
+    }): any;
+    variableStateValidation(inputs: {
+        catalog_item: string | Record<'sc_cat_item'>;
+        visible: string[];
+        not_visible: string[];
+        read_only: string[];
+        not_read_only: string[];
+        mandatory: string[];
+        not_mandatory: string[];
+    }): void;
+    assertResponseHeader(inputs: {
+        header_name: string;
+        response_operation: atf.AssertResponseHeader;
+        header_value: string;
+    }): void;
+    assertResponsePayload(inputs: {
+        response_body: string;
+        response_operation: atf.AssertResponsePayload;
+    }): void;
+}