Podręcznik API Script Guide

Zmienne globalne

Skrypt Instana Synthetic API używa następujących predefiniowanych zmiennych globalnych, aby przyspieszyć tworzenie skryptów:

controller:
  customProperties: "tag1=value1;tag2=value2"

// to print test custom tags/labels
console.log('Test Label $synthetic.labels.Team: ' + $synthetic.labels.Team);
console.log('Test Label $synthetic.labels.Purpose: ' + $synthetic.labels.Purpose);

$attributes.set('tag1', 'value1') // sets tag tag1 to value value1
let v = $attributes.get('tag1')   // sets variable v to the value of tag1

const assert = require('assert');

// Proxy with ip:port
// $network.setProxy('http://proxyhost:port');
// $network.setProxyForHttp('http://proxyhost:port');
// $network.setProxyForHttps('http://proxyhost:port');

// Proxy with authentication, create proxyUser and proxyPass credentials first
$network.setProxy('http://' + $secure.proxyUser + ':' + $secure.proxyPass + '@proxyhost:port');

// retrieve proxy
// let proxy = $network.getProxy();

// to redact 'key', 'password' and 'secret' query parameters in URL
$util.secrets.setURLSecretsRegExps([/key/i, /password/i, /secret/i]);

Wysyłanie żądań GET HTTP

Aby wysłać żądanie GET, należy użyć następującej składni:

const assert = require('assert');
(async function () {
    var options = {
      url: 'https://reqres.in/api/messages',
      https:{ rejectUnauthorized: false }
    };
  
    // Send GET request
    let response = await $got.get(options);

    // Validate the response status code, it should be 200 here
    assert.ok(response && response.statusCode == 200, 'Expect 200');
})();

Wysyłanie żądań HTTP POST

Aby wysłać żądanie JSON POST, należy użyć następującej składni:

const assert = require('assert');
(async function () {
    // Send JSON Data example
    let URL = 'https://reqres.in/api/users';

    // Define JSON data
    let data = {
      'job': 'leader',
      'name': 'morpheus'
    };

    // Make POST request
    let response = await $got.post(URL, {
      header: {
        'content-type': 'application/json'
      },
      json: data
    });

    // Validate the response code, if assertion fails, log "failed to create message, error is " plus 
    // results as error message on Synthetic dashboard
    assert.ok(response && response.statusCode == 201, 'expect 201');
})();

Aby wysłać żądanie formularza POST, należy użyć następującej składni:

const assert = require('assert');
(async function () {
    const response = await $got.post('https://httpbin.org/anything', {
      form: {
        text: 'hello world'
      }
    });

    assert.ok(response && response.statusCode == 200, 'expect 200');
})();    

Wysyłanie żądań obsługi TLS/SSL

Aby wysłać żądanie HTTPS i zezwolić na niezabezpieczony certyfikat, należy użyć następującej składni:

 // Allow the insecure certificate
 await $got('https://example.com', {
   https:{ rejectUnauthorized: false }
 });

Aby wysłać żądanie protokołu TLS/SSL z certyfikatem, należy użyć następującej składni:

 // Single key with passphrase
 await $got('https://example.com', {
   https: {
     key: $secure.key,
     certificate: $secure.certificate,
     passphrase: $secure.passphrase
   }
 });

Uwaga: Utwórz referencje do przechowywania klucza, certyfikatu i frazy hasła.

Wysyłanie żądań uwierzytelniania podstawowego

Aby wysłać żądanie podstawowego uwierzytelniania, należy użyć następującej składni:

 await $got.get('http://some.server.com/', {
   https:{ rejectUnauthorized: false },
   headers: {
     Authorization: "Basic " + $secure.AUTH_CRED
   }
 });

Uwaga: Należy utworzyć zmienną referencji AUTH_CRED , aby zapisać nazwę użytkownika i hasło podstawowego uwierzytelniania HTTP. Format zmiennej referencji AUTH_CRED jest następujący: username:password , która jest zakodowana przy użyciu kodowania base64.

Wysyłanie żądań z użyciem znacznika niedźwiedzia

Aby wysłać żądanie uwierzytelnienia niedźwiedzia, należy użyć następującej składni:

 await $got.get('http://some.server.com/', {
   headers: {
     'Authorization': "Bearer " + $secure.authToken
   }
 });

Uwaga: Utwórz informacje autoryzacyjne, aby zapisać tekst authToken .

Importowanie modułu opcjonalnego

Aby zaimportować obsługiwany moduł, wykonaj standardową procedurę importowania pliku Node.js . Patrz następujący przykład:

const crypto = require('crypto-js');

Obsługiwane moduły podstawowe

Obsługiwane są następujące moduły podstawowe:

• Asercja
• haki asynchroniczne
• bufor
• Stałe
• kryptografia
• dgram
• dns
• domena
• zdarzenia
• FS
• http
• http2
• https
• moduł
• net
• os
• najkrótszych
• haki wydajności
• Punycode
• QueryString
• pełnych
• dekoder łańcucha
• Liczniki czasu
• TLS
• Zdarzenia śledzenia
• tty
• url
• UTIL
• zlib,

Obsługiwane moduły innych firm

Obsługiwane są następujące moduły innych firm:

• assert-plus 1.0.0
• atob 2.1.2
• @aws-sdk/client-s3 3.387.0
• @babel/core 7.23.2
• basic-ftp 4.6.6
• analizator składni treści 1.20.0
• btoa 1.2.1
• klon 0.1.19
• kolory 1.4.0
• consoleplusplus 1.4.4
• crypto-js 4.2.0
• debug (debugowanie) 2.6.9
• rozszerz 3.0.2
• faker 5.5.3
• 11.8.6
• joi 17.6.0
• js-yaml 3.14.1
• jsprim 1.4.2
• kafkajs 2.2.4
• ldapauth-fork 5.0.5
• lodash 4.17.21
• moment 2.29.4
• net-snmp 3.8.2
• node-stream-zip 1.15.0
• prom-client 14.2.0
• bufory protokołu 4.2.0
• q 1.5.1
• żądanie 2.88.2
• powinno 13.2.3
• sip 0.0.6
• ssh2-sftp-client 7.2.3
• sshpk 1.17.0
• ssl-checker (kontroler SSL) 2.0.8
• swagger-analizator składni 8.0.4
• Kodowanie tekstu 0.7.0
• thrift 0.14.2
• twarda-informacja cookie 4.1.3
• podkreślenie 1.13.4
• rozpakowywanie 0.10.11
• url-parse 1.5.10
• urllib 2.41.0 ,
• uuid 3.4.0 ,
• analizator poprawności 13.7.0
• 7.5.8
• xml2js 0.5.0

Korzystanie z komendy script-cli

Aby przetestować i debugować skrypt API, należy użyć komendy script-cli , jak pokazano w poniższym przykładzie:

# Usage:
# test a single script
script-cli <script_name>
# test bundled scripts
script-cli -d <dir> <script-entry-file>
# Example:
script-cli examples/example1.js
script-cli -d examples/bundle-example1 index.js

Tworzenie pojedynczego testu skryptu interfejsu API

Po utworzeniu skryptu syntetycznego wykonaj następujące kroki:

1. Użyj programu synthetic-api-script , aby utworzyć skrypt interfejsu API i przekształcić go w łańcuch za pomocą komendy script-cli :

   # Usage:
   script-cli -s <script-file-path>
   # Example:
   script-cli -s examples/got-get.js
   

   W poniższym przykładzie przedstawiono wynik:

   {
     "syntheticType":"HTTPScript",
     "script":"var assert = require('assert');\n\n(async function() {\n  var options = {\n    url: 'https://httpbin.org/get',\n    https:{\n      rejectUnauthorized: false\n    }\n  };\n\n  let response = await $got.get(options);\n  assert.equal(response.statusCode, 200, 'Expected a 200 OK response');\n  console.log('Request URL %s, statusCode: %d', response.url, response.statusCode);\n})();\n"
   }
   

2. Skopiuj i wklej treść skryptu, aby zbudować następujący przykładowy kod JSON testu skryptu interfejsu API.

   {
     "label": "APIScript_Test",
     "active": true,
     "testFrequency": 1,
     "locations": ["DemoPoP1_saas_instana_test"],
     "configuration": {
       "syntheticType": "HTTPScript",
       "script": "converted script string"
     }
   }
   

Tworzenie testu spakowanego skryptu interfejsu API

Jeśli logika biznesowa jest złożona, nie należy zawierać wszystkich elementów w pojedynczym skrypcie, ponieważ programistom trudno jest zarządzać wieloma plikami skryptów w repozytorium Git .

Aby utworzyć test spakowanego skryptu interfejsu API, wykonaj następujące kroki:

1. Pakunki skryptów w skompresowanym pliku przy użyciu komendy script-cli :

   # Usage:
   script-cli -z <bundle-script-folder> <entry-script>
   # Example:
   script-cli -z bundle-example1 bundle-example1/index.js
   

2. Wypełnij pola scriptFile i bundle w konfiguracji testu danymi wyjściowymi komendy script-cli :

   • scriptFile jest punktem wejścia spakowanego skryptu.
   • bundle jest skompresowanym plikiem zakodowanym w formacie base64.

Aby utworzyć test pakietu syntetycznego, wypełnij ładunek testu, jak pokazano w poniższym przykładzie:

 {
   "label": "APIScriptBundle_Test",
   "active": true,
   "testFrequency": 5,
   "locations": ["DemoPoP1_saas_instana_test"],
   "configuration": {
     "syntheticType": "HTTPScript",
     "scripts": {
       "scriptFile": "index.js",
       "bundle": "zipped scripts encoded with base64"
     }
   }
 }

Przykład 1: skrypt interfejsu API Instana do testowania interfejsów API httpbin

Za pomocą skryptu API Instana można testować interfejsy API httpbin w następujący sposób:

const assert = require('assert');

(async function () {

    var getOptions = {
      url: 'https://httpbin.org/get',
      https:{ rejectUnauthorized: false },
      headers: {
        'Additional-Header': 'Additional-Header-Data'
      }
    };

    let getResponse = await $got.get(getOptions);
    console.info("Sample API - GET, response code: " + getResponse.statusCode);
    assert.ok(getResponse.statusCode == 200, "GET status is " + getResponse.statusCode + ", it should be 200");
    var bodyObj1 = JSON.parse(getResponse.body);
    assert.ok(bodyObj1.url == "https://httpbin.org/get", "httpbin.org REST API GET URL verify failed");

    var postOptions = {
      url: 'https://httpbin.org/post',
      json: {
        "name1": "this is the first data",
        "name2": "second data"
      },
      https:{ rejectUnauthorized: false },
      headers:{"accept": "application/json"}
    };

    let postResponse = await $got.post(postOptions);
    console.info("Sample API - POST, response code: " + postResponse.statusCode);
    assert.ok(postResponse.statusCode == 200, 'POST status is ' + postResponse.statusCode + ', it should be 200');
    const jsonBody2 = JSON.parse(postResponse.body);
    assert.equal(jsonBody2.json.name1, 'this is the first data', 'Expected this is the first data');
    assert.equal(jsonBody2.json.name2, 'second data', 'Expected second data');

    var putOptions = {
      url: 'https://httpbin.org/put',
      json: {
        "name1": 'this is the first data',
        "name2": 'second data'
      },
      https:{ rejectUnauthorized: false },
      headers:{"accept": "application/json"}
    };

    let putResponse = await $got.put(putOptions);
    console.info("Sample API - PUT, response code: " + putResponse.statusCode);
    assert.ok(putResponse.statusCode == 200, 'PUT status is ' + putResponse.statusCode + ', it should be 200');
    const jsonBody3 = JSON.parse(putResponse.body);
    assert.ok(jsonBody3.url == "https://httpbin.org/put", "httpbin.org REST API PUT URL verify failed");
    assert.equal(jsonBody3.json.name2, 'second data', 'Expected second data');

    var deleteOptions = {
      url: 'https://httpbin.org/delete',
      https:{ rejectUnauthorized: false },
      headers:{"accept": "application/json"}
    };

    let deleteResponse = await $got.delete(deleteOptions);
    console.info("Sample API - DELETE, response code: " + deleteResponse.statusCode);
    assert.ok(deleteResponse.statusCode == 200, 'DELETE status is ' + deleteResponse.statusCode + ', it should be 200');
    const jsonBody4 = JSON.parse(deleteResponse.body);
    assert.ok(jsonBody4.url == "https://httpbin.org/delete", "httpbin.org REST API DELETE URL verify failed");


    // to print environment variables
    console.info('List PoP environment variables using $synthetic API');
    console.info('Test ID:', $synthetic.TEST_ID);
    console.info('Test Name:', $synthetic.TEST_NAME);
    console.info('Location:', $synthetic.LOCATION);
    console.info('TimeZone:', $synthetic.TIME_ZONE);
    console.info('Job ID:', $synthetic.JOB_ID);

    // to print test custom tags/labels
    console.info('Test Label $synthetic.labels.Team: ' + $synthetic.labels.Team);
    console.info('Test Label $synthetic.labels.Purpose: ' + $synthetic.labels.Purpose);

    // to set custom tags dynamically
    $attributes.set('custom_tag1', 'value1');

})();

Przykład 2: skrypt interfejsu API Instana do testowania certyfikatu serwisu WWW

Za pomocą skryptu interfejsu API Instana można przetestować certyfikat SSL dla produktu ibm.com w następujący sposób:

const sslChecker = require('ssl-checker');
const assert = require('assert');

const hostname = 'ibm.com';
const remainDays = 90;

const getSslDetails = async(hostname) => {
  const result = await sslChecker(hostname);
  console.log(`certificate is valid: ${result.valid}`);
  console.log(`certificate expires on: ${result.validTo}`);
  console.log(`certificate days remaining: ${result.daysRemaining}`);

  assert.equal(result.valid, true, 'certificate of ibm should be valid');
  // this script will fail if the certificate remaining days less than 90 days by default
  // modify variable remainDays to any value as you need
  assert.equal(result.daysRemaining >= remainDays, true, `certificate validated remain days is less than ${remainDays} days`);
};

getSslDetails(hostname);

Więcej przykładów skryptu interfejsu API zawiera sekcja Skrypt syntetycznego interfejsu API.