API Reference

 type RequestBody = {
     type: BodyType,
     raw: string | undefined,
     form: KeyValue[] | undefined,
     files: KeyValue[] | undefined,
     graphql: GraphqlBody | undefined,
     binary: string | undefined
 }

// set JSON body
tc.request.setBody({
    color:"red"
  })
 
// set XML body
tc.request.setBody("<xml> xml_content </xml>");
 
// set Text body
tc.request.setBody("plain text body here");
 
// set Multi-part form
tc.request.setBody({
     form: [{
        name: "test",
        value: "123"
    }],
    files: [{
          name: "file1",
          value:"file_path_relative_or_absolute"
      }]
}, "formdata")
 
// set form-urlencoded
tc.request.setBody({
     form: [{
        name: "test",
        value: "123"
    }]
}, "formencoded")
 
 
// set GraphQL body
tc.request.setBody({
  query: `query {
      countries {
        name
      }
    }`,
  variables: {
        "data": {
          "hero": {
            "name": "R2-D2"
          }
        }
    }
}, "graphql")
 
// set Binary File body
tc.request.setBody("file_path/test.csv", "binary")
 

var name = tc.getVar("locationName");
 
var numberString = tc.getVar("incrementNumber");
 
var number = parseInt(numberString);

// To save to active environment
tc.setVar(varName, value);
 
// To save to local environment
tc.setVar(varName, value, "local");
 
// To save to global environment
tc.setVar(varName, value, "global");
 
// To set collection or request level variables
tc.setVar(varName, value, "request");

const finalUrl = tc.replaceVars(tc.request.url);
 
console.log(finalUrl);

console.log("load node module");
 
var moment = await tc.loadModule("moment");
 
// use moment specific version
var moment = await tc.loadModule("moment", "2.30.0");
 
console.log(moment().format());
tc.setVar("date", moment().format());

console.log("load local module");
 
var moment = tc.loadFromPath("thunder-tests/packages/node_modules/moment");

// To read a text file
await tc.readFile("filePath");
 
// To read file in base64 encoding
await tc.readFile("filePath", "base64");

// To get Absolute path of the file from relative path
var fullPath = tc.getAbsolutePath("testing.json");
 
var dataString = "124";
 
// To save to a file using full path
fs.appendFileSync(fullPath, dataString)

await tc.exec("node --version");

// get all cookies in store
var list = await tc.getCookies();
 
// get all cookies for current url
var listDomain = await tc.getCookies("url");
var listDomain = await tc.getCookies(tc.request.url);

// clear all cookies in store
await tc.clearCookies();
 
// clear all cookies for current domain
await tc.clearCookies("url");
await tc.clearCookies(tc.request.url);
 
// clear single cookie by name of cookie
await tc.clearCookies(tc.request.url, "cookieName");

// set cookie for current url
await tc.setCookie("https://www.thunderclient.com", "cookieName", "cookieValue");
await tc.setCookie(tc.request.url, "cookieName", "cookieValue");

// delay for 1 second.
await tc.delay(1000);

tc.test("Custom test name", true);
 
// assert response code is 200 without assertion library
tc.test("Response code is 200", tc.response.status === 200);
 
// assert response code is 200 with chai library
tc.test("Response code expect to be 200", function () {
      expect(tc.response.status).to.equal(200);
})

var result = await tc.runRequest("reqId");
 
// to get the request id dynamically
var result = await tc.runRequest(tc.request.id);
 
console.log(result);

await tc.retryRequest();

tc.skipRequest("reqId");

// version 2.21.4
 
declare var tc: tcType;
declare var expect: any;
declare var atob: any;
declare var btoa: any;
 
interface tcType {
    /**
      * Get Environment variable value
    * @param variableName variable name
    */
    getVar(variableName: string): string;
 
    /**
    * Set Environment variable value
    * @param variableName variable name
    * @param value variable value
    * @param scope [optional] environment scope with values: local, global and request
    */
    setVar(variableName: string, value: any, scope?: "local" | "global" | "request"): void;
 
    /**
    * Replace environment variables in the string
    * @param variableName variable name
    */
    replaceVars(variableName: string): string;
 
    /**
    * Add or update the query parameter of the URL
    * @param paramName query parameter name
    * @param value parameter value
    * @since 2.11.0
    */
    setParam(paramName: string, value: any): void;
 
    /**
    * Load and get node module from npm registry
    * @param moduleName module name
    * @param version [optional] module version, if empty latest version will be used
    */
    loadModule(moduleName: string, version?: string): Promise<any>;
 
    /**
     * Load a module from the specified folder path
     * @param modulePath module path relative to project root or absolute path
     * @since 2.21.0
     */
    loadFromPath(modulPath: string): any;
 
    /**
    * Read the file from disk
    * @param path file path relative to project root or absolute path
    * @param encoding [optional] encoding to use base64 or utf8. if empty utf8 will be used
    */
    readFile(path: string, encoding?: string): Promise<string | undefined>;
 
    /**
    * Executes the command and returns the result
    * @param command command to execute
    */
    exec(command: string): Promise<any>;
 
    /**
    * Get all cookies in cookie store
    * @param url [optional] to get cookies for url, if empty all cookies will be returned
    * @since 2.14.0
    */
    getCookies(url?: string): Promise<Cookie[]>;
 
    /**
    * Clear all existing cookies
    * @param url [optional] to clear cookies for url, if empty all cookies will be cleared
    * @param name [optional] to clear cookie by name, if empty all cookies for the url are cleared
    */
    clearCookies(url?: string, name?: string): Promise<void>;
 
    /**
    * Set cookie in cookie store
    * @param url the url to set cookie for
    * @param name cookie name
    * @param value cookie value
    * @since 2.14.0
    */
    setCookie(url: string, name: string, value: string): Promise<void>;
 
    /**
    * Delay the execution for the specified milliseconds
    * @param ms the delay time in milliseconds
    * @since 2.9.2
    */
    delay(ms: number): Promise<void>;
 
    /**
    * Test assertion (Only works in Post Request Script)
    * @param name the name of the test
    * @param result the result of the test -> boolean or function that returns false 
    * or throws exception
    * @since 2.10.0
    */
    test(name: string, result: boolean | (() => boolean | void)): void;
 
    /**
    * Run Request from the script
    * @param reqId the request id
    * @since 2.9.0
    */
    runRequest(reqId: string): Promise<ResponseModel>;
 
    /**
    * Retry Request from the script. This will not execute the pre-reqs and pre script
    * @since 2.17.5
    */
    retryRequest(): Promise<ResponseModel>;
 
    /**
    * Skip Request from execution in collection run
    * @param reqId the request id
    * @since 2.16.0
    */
    skipRequest(reqId: string): void;
 
    /**
    * Set the chart template and data
    * @param template chart template HTML string
    * @param data chart data
    * @since 2.17.0
    */
    chartHTML(template: string, data: any): void;
 
    /**
    * Get the Request Info
    * @since 2.15.0
    */
    info: InfoModel;
 
    /**
    * Get the Request object (Only Headers can be modified)
    */
    request: RequestModel;
 
    /**
    * Get the Response object (read-only)
    */
    response: ResponseModel;
}
 
type RequestModel = {
    id: string;
    name: string;
    url: string;
    method: string;
    headers: KeyValue[];
    body: RequestBody | undefined;
    auth: Authentication | undefined;
    getHeader(name: string): string | undefined;
    setHeader(name: string, value: string): void;
    /**
      * Set Request body
    */
    setBody(body: string | object | GraphqlBody | undefined, type?: BodyType): void;
}
 
type ResponseModel = {
    status: number;
    time: number;
    size: number;
    contentType: string;
    headers: KeyValue[];
    cookies: KeyValue[];
    json: any;
    text: string;
    getHeader(name: string): string | undefined;
    getBinary(): Buffer | undefined;
}
 
type RequestBody = {
    type: BodyType,
    raw: string | undefined,
    form: KeyValue[] | undefined,
    files: KeyValue[] | undefined,
    graphql: GraphqlBody | undefined,
    binary: string | undefined
}
 
type KeyValue = {
    name: string,
    value: string,
    isDisabled?: boolean | undefined
}
 
type BodyType = "none"|"text"|"json"|"xml"|"formdata"|"formencoded"|"graphql"|"binary";
 
type GraphqlBody = {
    query: string,
    variables?: string | undefined
}
 
type Cookie = {
    key: string;
    value: string;
    expires?: string; // date in ISO 8601 format
    domain: string;
    path: string;
    hostOnly: boolean;
    httpOnly?: boolean;
    creation: string;  // date in ISO 8601 format
    lastAccessed: string;  // date in ISO 8601 format
}
 
type InfoModel = {
    environmentName: string,
    requestName: string,
    collectionName: string,
    folderName: string,
    currentIteration: number,
    totalIterations: number
}