Rungutan Documentation

Rungutan is the first API Load Testing SaaS platform, 100% Serverless, API driven, finally available for SMBs.

As an evolved creature, Rungutan has extensive Load-Testing abilities, gained by experience, in order to survive in a fast-paced environment. Load Testing is its first language, so you will get along very well.

Useful links:

1. Landing page

2. Rungutan Platform

3. Rungutan Documentation

Design workflow oriented strategies

With sophisticated yet witty tools, a Rungutan is always prepared for what nature brings. Learning from this behaviour, our platform helps you simulate workflows to emulate user experience.

User’s nature will never surprise you again!

Share results with your team members and define test-cases together

Rungutans love spending time and working by themselves, but as many IT professionals, they have to socialize from time to time and show their wins.

With this platform you can do that as well!

Schedule cron jobs to run against your platform regularly, for all-time awareness

These creatures always have each other’s back. They’ve developed multiple exercises in order to always be prepared in case of trouble.

You can now do the same!

Reach up to 100.000 requests/second in 15 concurrent regions

This species is more evolved than any other primates. It’s the first one who can actually Run. Why so?

Because due to its flexibility and simple design, can reach up to 100.000 requests/second.

Sample workflows

Here’s some sample workflows to show you the power of Rungutan:

LANDING PAGE

{
  "test_name": "Blog post test",
  "num_clients": 250,
  "hatch_rate": 250,
  "run_time": 60,
  "threads_per_region": 1,
  "domain_name": "my-landing-page.com",
  "protocol": "https",
  "test_region": [ "us-east-1" ],
  "workflow": [
    {
      "path": "/",
      "method": "GET"
    },
    {
      "path": "/blog",
      "method": "GET"
    },
    {
      "path": "/blog/post-1",
      "method": "GET"
    },
  ]
}

BASIC AUTH

{
  "test_name": "Blog post behind nginx HTTP access basic auth",
  "num_clients": 250,
  "hatch_rate": 250,
  "run_time": 60,
  "threads_per_region": 1,
  "domain_name": "my-basic-site.com",
  "protocol": "https",
  "test_region": [ "us-east-1" ],
  "workflow": [
    {
      "path": "/",
      "method": "GET",
      "headers": {
         "Authorization": "Basic some-token-here"
      }
    },
    {
      "path": "/blog",
      "method": "GET",
      "headers": {
         "Authorization": "Basic some-token-here"
      }
    },
    {
      "path": "/blog/post-1",
      "method": "GET",
      "headers": {
         "Authorization": "Basic some-token-here"
      }
    },
  ]
}

JSON RESPONSE WITH PATH EXPRESSION

{
    "num_clients": 30,
    "hatch_rate": 1,
    "run_time": 30,
    "threads_per_region": 1,
    "workflow": [
        {
            "path": "/v1/api/tests/list",
            "method": "POST",
            "headers": {
                "Content-Type": "application/json",
                "X-Api-Key": "${vault.api_key}"
            },
            "extract": [
                {
                    "parameter_name": "test_id",
                    "location": "body",
                    "json_path_expression": "Tests[*].test_id"
                }
            ],
            "data": "{\"team_id\":\"rungutan\"}",
            "files": []
        },
        {
            "path": "/v1/api/tests/get",
            "method": "POST",
            "headers": {
                "Content-Type": "application/json",
                "X-Api-Key": "${vault.api_key}"
            },
            "data": "{\"team_id\":\"rungutan\", \"test_id\":\"${test_id}\"}",
            "extract": [],
            "files": []
        }
    ],
    "domain_name": "app.rungutan.com",
    "protocol": "https",
    "test_region": [
        "eu-west-1",
        "eu-west-2"
    ],
    "min_wait": 1000,
    "max_wait": 1000,
    "file_name_certificate": "",
    "test_name": "List all tests, extract a random test_id using path expression and fetches its details"
}

First workflow step:

• Hit the /v1/api/tests/list path with POST

• Inject the X-Api-Key header with the relevant Vault key

• Extract a random “test_id” key from the “Tests” array in the JSON response and STORE it in the variable named “test_id”

Second workflow step:

• Hit the /v1/api/tests/get path with POST

• Inject the X-Api-Key header with the relevant Vault key

• Set the payload as “{“team_id”:”rungutan”, “test_id”:”${test_id}”}” by referencing the value of the variable that we extracted in the previous step

BASIC AUTH WITH FILE UPLOAD

{
  "test_name": "Upload file to site with basic auth",
  "num_clients": 250,
  "hatch_rate": 250,
  "run_time": 60,
  "threads_per_region": 1,
  "domain_name": "my-basic-site.com",
  "protocol": "https",
  "test_region": [ "us-east-1" ],
  "workflow": [
    {
      "path": "/",
      "method": "GET",
      "files": [
         "file1", "file2"
      ]
      "headers": {
         "Authorization": "Basic some-token-here"
      }
    },
    {
      "path": "/blog",
      "method": "GET",
      "headers": {
         "Authorization": "Basic some-token-here"
      }
    },
    {
      "path": "/blog/post-1",
      "method": "GET",
      "files": [
         "file3"
      ]
      "headers": {
         "Authorization": "Basic some-token-here"
      }
    },
  ]
}

JWT LOGIN PLATFORM

{
  "test_name": "Platform with JWT based auth",
  "num_clients": 250,
  "hatch_rate": 250,
  "run_time": 60,
  "threads_per_region": 1,
  "domain_name": "my-jwt-platform.com",
  "protocol": "https",
  "test_region": [ "us-east-1" ],
  "workflow": [
       {
           "path": "/login",
           "method": "POST",
           "headers": {
               "Content-Type": "application/x-www-form-urlencoded"
           },
           "data": "user=${vault.username}&password=${vault.password}",
           "extract": [
               {
                   "parameter_name": "authtoken",
                   "location": "body",
                   "key": "access_token",
                   "default_value": ""
               }
           ]
       },
       {
           "path": "/results",
           "method": "POST",
           "data": "{\"result_id\": \"1\"}"
           "headers": {
               "Authorization": "Bearer ${authtoken}"
           }
       }
   ]
}

First workflow step:

• Hit the /login path with POST

• Inject the username and password values from the relevant Vault keys into the payload

• Extract the “access_token” key from the JSON response and STORE it in the variable named “authtoken”

Second workflow step:

• Hit the /results path witht POST

• Include a payload in the request

• Set the header as “Bearer ${authtoken}” by referencing the value of the variable that we extracted in the previous step

LOGIN E-COMMERCE AND VIEW ORDERS

{
    "test_name": "Log in and view orders on e-commerce website",
    "num_clients": 60,
    "hatch_rate": 60,
    "run_time": 60,
    "threads_per_region": 5,
    "workflow": [
        {
            "path": "/login",
            "method": "GET",
            "headers": {
                "Content-Type": "application/x-www-form-urlencoded"
            },
            "extract": [
                {
                    "parameter_name": "csrftoken",
                    "location": "body",
                    "element_with_regex": "meta name=\"csrf-token\" content=\"(.+?)\""
                }
            ]
        },
        {
            "path": "/login",
            "method": "POST",
            "headers": {
                "Content-Type": "application/x-www-form-urlencoded"
            },
            "data": "email=${csv.testprod.0}&password=${csv.testprod.1}&csrftoken=${csrftoken}",
            "extract": [
                {
                    "parameter_name": "auth_code",
                    "location": "header",
                    "key": "SESSION"
                }
            ]
        },
        {
            "path": "/profile/orders",
            "method": "GET",
            "headers": {
                "SESSION": "${auth_code}"
            }
        }
    ],
    "domain_name": "domain.com",
    "protocol": "https",
    "test_region": [
        "us-east-1",
        "us-east-2"
    ]
}

First workflow step:

• Hit the login URL with the METHOD GET

• EXTRACT the CSRF token value by scanning the page for the actual value of csrf-token and STORE IT with variable name csrftoken

Second workflow step:

• Use the value of the PREVIOUSLY STORED variable csrftoken and construct the LOGIN credentials by fetching the username and password from the CSV file testprod which are stored in columns with indexes 0 and 1 respectively

• Hit that URL with the METHOD POST

• EXTRACT the SESSION header value and STORE IT with variable name auth_code

Third workflow step:

• Use the SAME value of the PREVIOUSLY STORED variable auth_code and place it in the SESSION header

• Hit the orders URL with the METHOD GET

CSV UPDATE USER DETAILS

{
    "test_name": "Update email + phone number - 1000 users csv",
    "num_clients": 60,
    "hatch_rate": 60,
    "run_time": 60,
    "threads_per_region": 5,
    "workflow": [
        {
            "path": "/user/${csv.testprod.3}/profile",
            "method": "GET",
            "data": "",
            "headers": {
                "Content-Type": "application/json",
                "Authorization": "${vault.api_key}"
            },
            "extract": [
                {
                    "parameter_name": "profile_id",
                    "location": "body",
                    "key": "profile_id_extracted"
                }
            ]
        },
        {
            "path": "/user/${profile_id_extracted}/profile-details",
            "method": "POST",
            "data": "{\"phone_number\": \"+14041234567\"}",
            "headers": {
                "Content-Type": "application/json",
                "Authorization": "${vault.api_key}"
            }
        },
        {
            "path": "/user/${profile_id_extracted}/profile-details",
            "method": "POST",
            "data": "{\"email\": \"[email protected]"}",
            "headers": {
                "Content-Type": "application/json",
                "Authorization": "${vault.api_key}"
            }
        }
    ],
    "domain_name": "domain.com",
    "protocol": "https",
    "test_region": [
        "us-east-1",
        "us-east-2"
    ]
}

Here’s the step by step long explanation:

First workflow step:

• Extract a random ROW from file testprod

• From that ROW, get the value of the COLUMN with index 3

• With that value, construct the URL -> /user/${csv.testprod.3}/profile

• Hit that URL with the METHOD GET

• Authenticate the API request using a VAULT key with the name api_key by placing it in the header key called “Authorization”

• EXTRACT the parameter profile_id from the received JSON response and STORE IT with variable name profile_id_extracted

Second workflow step:

• Use the value of the PREVIOUSLY STORED variable profile_id_extracted and construct the URL -> /user/${profile_id_extracted}/profile-details

• Hit that URL with the METHOD POST

• Authenticate the API request using a VAULT key with the name api_key by placing it in the header key called “Authorization”

• Push the appropriate PAYLOAD using the json-escaped data field in order to update the phone number

Third workflow step:

• Use the SAME value of the PREVIOUSLY STORED variable profile_id_extracted and construct the URL -> /user/${profile_id_extracted}/profile-details

• Hit that URL with the METHOD POST

• Authenticate the API request using a VAULT key with the name api_key by placing it in the header key called “Authorization”

• Push the appropriate PAYLOAD using the json-escaped data field in order to update the email address

Table of contents

• Fun facts
  • Concurrent regions list
  • Overall mode
  • Threads per region logic
  • Simulate 10 million requests per minute
  • JSON payload
  • Extract nested json response
  • Extract nested json response with array
  • Extract specific key with json path expression from response body
  • Extract random key from collection of items with json path expression from response body
  • Extract using regex
  • Sharing secret stuff
  • Why blank steps :(
• Sample workflows
  • LANDING PAGE
  • BASIC AUTH
  • BASIC AUTH WITH FILE UPLOAD
  • JSON RESPONSE WITH PATH EXPRESSION
  • JWT LOGIN PLATFORM
  • LOGIN E-COMMERCE AND VIEW ORDERS
  • CSV UPDATE USER DETAILS
• Teams
• API Keys
  • Get your API key
  • Refresh your API key
• Dashboard
• Alerts
  • Permissions
  • How do I create Slack Incoming Webhooks ?
  • List alerts
  • Add alert
  • Remove alerts
• Vault
  • Permissions
  • List vault keys
  • Add vault key
  • Get vault key value
  • Remove key
• File System
  • Permissions
  • List files
  • Upload file
  • Download file
  • Remove file
• CSV
  • Permissions
  • List CSV files
  • Upload CSV file
  • Download CSV file
  • Remove CSV file
• Certificate
  • Permissions
  • List certificate files
  • Upload certificate file
  • Download certificate file
  • Remove certificate file
• Tests
  • Permissions
  • Test properties
  • Good to know!
  • List tests
  • Start test
  • Cancel test
  • Get test details
  • Set test sharing
  • Remove test
• Templates
  • Permissions
  • Template properties
  • List templates
  • Add template
  • Get template details
  • Remove template
• Cron jobs
  • Permissions
  • Cron properties
  • List crons
  • Start cron
  • Set cron status
  • Get cron details
  • Remove cron
• Integrations
  • GitLab Pipelines
  • Jenkins CI/CD
  • GitHub Actions
• Results
  • Permissions
  • Raw results
  • Test summary
  • Test failures
  • Test detailed stats
  • Test progress
  • Test graphs
• Domains
  • Permissions
  • List domains
  • Add domains
  • Validate domains
  • Remove domains
• Team members
  • Permissions
  • List members
  • Get self role
  • Add members
  • Change member role
  • Remove member
• Profile
• Billing
  • Subscription type
  • What are credits?
  • How do you compute costs for Pay-Per-Test?
  • Changing the subscription type completely
  • Coupon codes
  • VAT processing
  • Subscription changes
  • Payment method change
  • Subscription cancellation