# Script
This is a node that runs JavaScript scripts. It is going to help you solve the following tasks:
* create complex tests to check the results of one or several nodes;
* generate test data;
* change other nodes' variables;
* perform operations to bring the tested system to a specific state (set\_up, tear\_down);
* debug and access all nodes' states.
## Editing a Script
The script node editing window is divided into two parts: the code editor and the console output window. To close the console window click the 
button.
You can use the toolbar above the output window to manage the console behavior:
/- choose what to do with the console output.  - clear the window every time you run a script,  - display all previous outputs.
*  - auto scroll to the last line of the output
*  - clear the console window
## Running a Script
Click the `RUN` button to execute the script. The execution continues to the last line of the code and finishes when all asynchronous tasks are done (e.g.`setTimeout`). The execution is successful if:
* there are no syntax errors in the code;
* the exceptions raised had been handled;
* the execution took no more than 30 seconds (otherwise the execution will be terminated).
{% hint style="success" %}
Since the call to the script is wrapped in a function, you need to use the `return;`command to avoid errors while terminating the script.
{% endhint %}
{% hint style="danger" %}
To get an error after script termination raise an exception with`throw new Error('Something went wrong');`
{% endhint %}
## Libraries
The script is executed in the Node.js virtual environment. Some Node.js modules and all standard JavaScript features supported by V8 are available.
{% hint style="info" %}
The ECMAScript 6 standard is supported as well.
{% endhint %}
### Available Node.js modules
* [fs](https://nodejs.org/docs/latest-v10.x/api/fs.html) - a module for interacting with the file system
### Available third party libraries
* [lodash](https://lodash.com/) - a library that provides lots of utility functions
* [moment.js](https://momentjs.com/) - a library for managing dates
* [CryptoJS](https://cryptojs.gitbook.io/docs/) - a collection of cryptographic algorithms
* [random-js](https://github.com/ckknight/random-js) - a mathematically correct random number generator library
* [faker.js](https://github.com/marak/Faker.js/) - a library that lets you generate random data for different entities properties
* [chai.js](https://www.chaijs.com/) - a library that provides a convenient API for making assertions
* [request](https://github.com/request/request) - a library that provides a simplified HTTP client
## Execution Context
Objects and functions of the script's global scope are listed below.
### Accessing third party modules
Every module stated above is automatically added to the execution context and is available in the global scope.
#### lodash
```javascript
const chunks = _.chunk([1, 2, 3, 4], 2);
```
#### moment.js
```javascript
const now = moment();
```
#### CryptoJS
```javascript
const hash = crypto.MD5('Message');
```
#### random-js
```javascript
const randomEngine = new random.Random();
const shuffledArray = randomEngine.shuffle([1,2,3,4,5]);
```
#### faker.js
```javascript
const person = {
'name': faker.name.findName(),
'email': faker.internet.email()
};
```
#### chai.js
```javascript
const foo = 'bar';
// success
assert.equal(foo, 'bar');
expect(foo).to.equal('bar');
// failure
assert.equal(1, 0);
```
#### request
```javascript
request('https://docs-ru.testmace.com', (error, response, body) => {
assert.equal(error, null);
assert.equal(response.statusCode, 200);
assert.notEqual(body, null);
});
```
### console.\*
There are different console output methods, such as log, info, warn, error, debug, exception.
Their signatures are equal to the signatures of their standard versions. In the console every method type is highlighted in different color. Each colored line contains the particular row and column where the output method is called. Events of the exception type are displayed along with the stack trace.
### Navigating your project
There is an object used to access the project and the current Script node. It is called `tm` and it is available in the global scope.
#### tm
* `currentNode: nodeAPI` - the current Script node API
* `project: nodeAPI` - the project node API
* `env: envAPI` - the API for accessing the environment variables
* `cookies: cookie[]` - a list of cookies used in the project
#### nodeAPI
* `parent: nodeAPI` - returns a parent node API and null for the project node
* `name: string` - the given node name
* `type: string` - the given node type
* `path: string` - the path to the given node starting with the project root
* `children: nodeAPI[]` - a list of child nodes APIs
* `findChild(name: string): nodeAPI` - searches for the child node using its name and returns null if the node doesn't exist
* `next: nodeAPI` - the API of the next node in the group. If the given node is the last one, null is returned
* `prev: nodeAPI` - the API of the previous node in the group. If the given node is the first one, null is returned
* `nextNodes: nodeAPI[]` - a list of all next nodes in the group. If the given node is the last one, an empty list is returned
* `prevNodes: nodeAPI[]` - a list of all previous nodes in the group. If the given node is the first one, an empty list is returned
* `vars: object` - the object that stores all static variables of the given node
* `dynamicVars: object` - the object that stores all dynamic variables of the given node
* `setDynamicVar(name: string, value: any): void` - sets the name dynamic variable with a certain value for the given node
#### requestNodeAPI
The interface of a `RequestStep` node is more advanced.
* `request: object` - the object that stores the node's request configuration
* `response: object` - the object that stores the results of the last request
#### envAPI
* `active: string` - the active environment title
* `vars: object` - the object that stores the current environment variables
## Code examples
### Recursive traversal of the node's children
```javascript
const current = tm.currentNode;
const parent = current.parent;
if (!parent) {
console.warn(`Parent of ${current.path} not found`);
return;
}
const value = parent.vars['ID'];
if (!value) {
console.warn(`Node ${parent.path} hasn't have value for ID`);
return;
}
console.log(`Parent ID = ${value}`);
const setIDToNode = (node) => {
node.setDynamicVar('ID', value);
};
const traverseDescendants = (node, func, depth) => {
node.children.forEach((child) => {
func(node);
indent = '\t'.repeat(depth);
console.debug(
`${indent}${child.path}`,
`${indent}Value: ${child.dynamicVars['ID']}`
);
traverseDescendants(child, func, depth+1);
});
};
traverseDescendants(parent, setIDToNode, 0);
```
### Searching a node by its name
```javascript
const current = tm.currentNode;
const scriptNode = current.parent.findChild(current.name);
assert.equal(current, scriptNode);
```
## File Representation
```javascript
{
"type": "object",
"properties": {
"type": {
"description": "Type of Script node",
"const": "Script",
"type": "string"
},
"script": {
"description": "Javascript code",
"type": "string"
},
"children": {
"description": "List of children names",
"type": "array",
"items": {
"type": "string"
},
"default": []
},
"variables": {
"$ref": "#/definitions/NodeVariables",
"description": "Node variables dictionary"
},
"name": {
"description": "Node name",
"type": "string"
}
},
"required": [
"children",
"name",
"script",
"type",
"variables"
],
"definitions": {
"NodeVariables": {
"type": "object",
"additionalProperties": {
"type": "string"
}
}
},
"$schema": "http://json-schema.org/draft-07/schema#"
}
```