🥮 mooncakes.io
    Sign in

    k6

    A MoonBit module for k6 load testing scripts, providing utilities and abstractions to enhance the development experience of k6 scripts using MoonBit.

    k6
    load testing
    Download zip
    Author
    Version
    0.4.1
    License
    Apache-2.0
    Repository
    Last updated
    7 months ago
    Downloads
    24

    Dependencies

    #ryota0624/k6

    k6のMoonBitバインディング

    #概要

    このライブラリは、k6 JavaScript APIの型安全なMoonBitバインディングを提供します。MoonBitで完全な型安全性を持つ負荷テストを記述し、JavaScriptにコンパイルしてk6で実行できます。

    #提供機能

    #コアモジュール

    #ネットワーク＆プロトコル

    #データ＆エンコーディング

    #テスト＆メトリクス

    #ユーティリティ

    #利用例

    exampleディレクトリには、MoonBitで書かれたk6スクリプトのサンプルが含まれています。

    #ライセンス

    Apache-2.0

    DefaultFunction

    source
    type DefaultFunction = (
    Any    ) -> Unit

    Default (VU) function that runs for each iteration Receives the data returned from setup

    OnCloseHandler

    source
    type OnCloseHandler = (
    Any    ) -> Unit

    Event handler for WebSocket close

    OnErrorHandler

    source
    type OnErrorHandler = (
    Any    ) -> Unit

    Event handler for WebSocket error

    OnMessageHandler

    source
    type OnMessageHandler = (
    Any    ) -> Unit

    Event handler for WebSocket message

    OnOpenHandler

    source
    type OnOpenHandler = (
    Any    ) -> Unit

    Event handler for WebSocket connection open

    SetupFunc

    source
    type SetupFunc = () -> 
    Any

    Setup function type - runs once before test

    SetupFunction

    source
    type SetupFunction = () -> 
    Any

    Setup function that runs once before the test Returns data that will be passed to the default function

    TeardownFunc

    source
    type TeardownFunc = (
    Any    ) -> Unit

    Teardown function type - runs once after test

    TeardownFunction

    source
    type TeardownFunction = (
    Any    ) -> Unit

    Teardown function that runs once after the test Receives the data returned from setup

    VUFunc

    source
    type VUFunc = (
    Any    ) -> Unit

    VU function type - runs for each VU iteration

    ApiKeyAuth

    source
    pub struct ApiKeyAuth {
      key : String
      header_name : String
    }

    API Key Authentication

    ApiKeyAuth::new

    source
    fn ApiKeyAuth::new(key : String, header_name : String) -> ApiKeyAuth

    Create API Key Auth

    AuthSession

    source
    pub struct AuthSession {
      auth_type : String
      credentials : 
    Any
      headers : Map[String, String]
    }

    Session with authentication

    AuthSession::api_key

    source
    fn AuthSession::api_key(key : String, header_name : String) -> AuthSession

    Create session with API Key

    AuthSession::basic

    source
    fn AuthSession::basic(username : String, password : String) -> AuthSession

    Create session with Basic Auth

    AuthSession::bearer

    source
    fn AuthSession::bearer(token : String) -> AuthSession

    Create session with Bearer token

    BasicAuth

    source
    pub struct BasicAuth {
      username : String
      password : String
    }

    Basic Authentication credentials

    BasicAuth::new

    source
    fn BasicAuth::new(username : String, password : String) -> BasicAuth

    Create Basic Auth

    BearerAuth

    source
    pub struct BearerAuth {
      token : String
    }

    Bearer Token Authentication

    BearerAuth::new

    source
    fn BearerAuth::new(token : String) -> BearerAuth

    Create Bearer Auth

    Counter

    source
    pub struct Counter {
      name : String
      is_time : Bool
      handle : 
    Any
    }

    Counter metric - counts occurrences

    Counter::add

    source
    fn Counter::add(self : Counter, value : Double) -> Unit

    Add a value to the counter

    Counter::add_value

    source
    fn Counter::add_value(self : Counter, value : Double) -> Unit

    Add value to counter

    Counter::increment

    source
    fn Counter::increment(self : Counter) -> Unit

    Increment counter by 1

    Counter::new

    source
    fn Counter::new(name : String, is_time : Bool) -> Counter

    Create a new Counter metric

    Gauge

    source
    pub struct Gauge {
      name : String
      is_time : Bool
      handle : 
    Any
    }

    Gauge metric - tracks the latest value

    Gauge::add

    source
    fn Gauge::add(self : Gauge, value : Double) -> Unit

    Set the gauge value

    Gauge::new

    source
    fn Gauge::new(name : String, is_time : Bool) -> Gauge

    Create a new Gauge metric

    Gauge::set

    source
    fn Gauge::set(self : Gauge, value : Double) -> Unit

    Set gauge value

    GroupConfig

    source
    pub struct GroupConfig {
      name : String
      tags : Map[String, String]
    }

    Group configuration

    GroupConfig::new

    source
    fn GroupConfig::new(name : String) -> GroupConfig

    Create group config

    GroupConfig::run

    source
    fn[T : Default] GroupConfig::run(self : GroupConfig, body : () -> T) -> T

    Execute group with config

    GroupConfig::tag

    source
    fn GroupConfig::tag(self : GroupConfig, key : String, value : String) -> GroupConfig

    Add tag to group

    HttpMetrics

    source
    pub struct HttpMetrics {
      requests : Counter
      success_rate : Rate
      duration : Trend
    }

    Track all HTTP metrics at once

    HttpMetrics::new

    source
    fn HttpMetrics::new(prefix : String) -> HttpMetrics

    Create HTTP metrics set

    HttpMetrics::track

    source
    fn HttpMetrics::track(self : HttpMetrics, res : Response) -> Unit

    Track HTTP response with all metrics

    OAuthToken

    source
    pub struct OAuthToken {
      access_token : String
      token_type : String
      expires_in : Int?
      refresh_token : String?
    }

    OAuth 2.0 token response

    Options

    source
    pub struct Options {
      vus : Int?
      duration : String?
      iterations : Int?
      stages : Array[
    Any    ]?
      thresholds : Map[String, Array[String]]?
      scenarios : Map[String, 
    Any    ]?
      tags : Map[String, String]?
      no_connection_reuse : Bool?
      user_agent : String?
    }

    Test options configuration

    Options::default

    source
    fn Options::default() -> Options

    Create default Options

    Options::duration

    source
    fn Options::duration(self : Options, duration : String) -> Options

    Set duration

    Options::iterations

    source
    fn Options::iterations(self : Options, iterations : Int) -> Options

    Set iterations

    Options::tags

    source
    fn Options::tags(self : Options, tags : Map[String, String]) -> Options

    Set tags

    Options::thresholds

    source
    fn Options::thresholds(self : Options, thresholds : Map[String, Array[String]]) -> Options

    Set thresholds

    Options::to_js

    source

    Convert Options to JS object

    Options::user_agent

    source
    fn Options::user_agent(self : Options, user_agent : String) -> Options

    Set user agent

    Options::vus

    source
    fn Options::vus(self : Options, vus : Int) -> Options

    Set VUs (virtual users)

    Params

    source
    pub struct Params {
      headers : Map[String, String]
      tags : Map[String, String]
      timeout : String?
    }

    HTTP request parameters

    Params::default

    source
    fn Params::default() -> Params

    Create default Params

    Rate

    source
    pub struct Rate {
      name : String
      is_time : Bool
      handle : 
    Any
    }

    Rate metric - tracks the percentage of non-zero values

    Rate::add

    source
    fn Rate::add(self : Rate, value : Bool) -> Unit

    Add a value to the rate (true = success, false = failure)

    Rate::failure

    source
    fn Rate::failure(self : Rate) -> Unit

    Record failure

    Rate::new

    source
    fn Rate::new(name : String, is_time : Bool) -> Rate

    Create a new Rate metric

    Rate::record

    source
    fn Rate::record(self : Rate, success : Bool) -> Unit

    Record result (true = success, false = failure)

    Rate::success

    source
    fn Rate::success(self : Rate) -> Unit

    Record success

    RequestBuilder

    source
    pub struct RequestBuilder {
      http_method : String
      url : String
      body : 
    Any    ?
      headers : Map[String, String]
      tags : Map[String, String]
      timeout : String?
    }

    HTTP Request Builder for fluent API

    RequestBuilder::api_key_auth

    source
    fn RequestBuilder::api_key_auth(self : RequestBuilder, key : String, header_name : String) -> RequestBuilder

    Add API Key authentication

    RequestBuilder::basic_auth

    source
    fn RequestBuilder::basic_auth(self : RequestBuilder, username : String, password : String) -> RequestBuilder

    Add Basic Authentication to request

    RequestBuilder::bearer_auth

    source
    fn RequestBuilder::bearer_auth(self : RequestBuilder, token : String) -> RequestBuilder

    Add Bearer token authentication

    RequestBuilder::custom_auth

    source
    fn RequestBuilder::custom_auth(self : RequestBuilder, header_value : String) -> RequestBuilder

    Add custom authentication header

    RequestBuilder::delete

    source
    fn RequestBuilder::delete(url : String) -> RequestBuilder

    Create a new DELETE request builder

    RequestBuilder::get

    source
    fn RequestBuilder::get(url : String) -> RequestBuilder

    Create a new GET request builder

    RequestBuilder::header

    source
    fn RequestBuilder::header(self : RequestBuilder, key : String, value : String) -> RequestBuilder

    Add a header

    RequestBuilder::headers

    source
    fn RequestBuilder::headers(self : RequestBuilder, headers_map : Map[String, String]) -> RequestBuilder

    Add multiple headers

    RequestBuilder::json

    source

    Set request body as JSON

    RequestBuilder::oauth_token

    source
    fn RequestBuilder::oauth_token(self : RequestBuilder, token : OAuthToken) -> RequestBuilder

    Use OAuth token with request

    RequestBuilder::patch

    source
    fn RequestBuilder::patch(url : String) -> RequestBuilder

    Create a new PATCH request builder

    RequestBuilder::post

    source
    fn RequestBuilder::post(url : String) -> RequestBuilder

    Create a new POST request builder

    RequestBuilder::put

    source
    fn RequestBuilder::put(url : String) -> RequestBuilder

    Create a new PUT request builder

    RequestBuilder::send

    source

    Execute the request and return Response

    RequestBuilder::tag

    source
    fn RequestBuilder::tag(self : RequestBuilder, key : String, value : String) -> RequestBuilder

    Add a tag

    RequestBuilder::text

    source
    fn RequestBuilder::text(self : RequestBuilder, data : String) -> RequestBuilder

    Set request body as text

    RequestBuilder::timeout

    source
    fn RequestBuilder::timeout(self : RequestBuilder, timeout : String) -> RequestBuilder

    Set timeout

    RequestBuilder::with_session

    source
    fn RequestBuilder::with_session(self : RequestBuilder, session : AuthSession) -> RequestBuilder

    Apply session auth to request builder

    Response

    source
    pub struct Response {
      status : Int
      status_text : String
      body : String
      headers : Map[String, String]
      json : 
    Any
      html : 
    Any
      timings : 
    Any
    }

    HTTP Response type Represents the response from an HTTP request

    Response::is_ok

    source
    fn Response::is_ok(self : Response) -> Bool

    Check if response status is 2xx

    Response::is_status

    source
    fn Response::is_status(self : Response, code : Int) -> Bool

    Check if response status is specific code

    Response::json_body

    source
    fn Response::json_body(self : Response) -> 
    Any

    Get JSON body as Any

    Response::text_body

    source
    fn Response::text_body(self : Response) -> String

    Get text body

    Scenario

    source
    pub struct Scenario {
      executor : String
      vus : Int?
      iterations : Int?
      duration : String?
      start_time : String?
      graceful_stop : String?
      exec : String?
    }

    Scenario configuration

    Scenario::default

    source
    fn Scenario::default() -> Scenario

    Create default Scenario

    Scenario::duration

    source
    fn Scenario::duration(self : Scenario, duration : String) -> Scenario

    Set duration for scenario

    Scenario::executor

    source
    fn Scenario::executor(self : Scenario, executor : String) -> Scenario

    Set executor type

    Scenario::iterations

    source
    fn Scenario::iterations(self : Scenario, iterations : Int) -> Scenario

    Set iterations for scenario

    Scenario::to_js

    source

    Convert Scenario to JS object

    Scenario::vus

    source
    fn Scenario::vus(self : Scenario, vus : Int) -> Scenario

    Set VUs for scenario

    SharedArray

    source
    pub struct SharedArray {
      name : String
      handle : 
    Any
    }

    Shared array for sharing data between VUs

    SharedArray::get

    source
    fn SharedArray::get(self : SharedArray, index : Int) -> 
    Any

    Get value from SharedArray by index

    SharedArray::length

    source
    fn SharedArray::length(self : SharedArray) -> Int

    Get the length of the SharedArray

    SharedArray::new

    source
    fn SharedArray::new(name : String, callback : () -> 
    Any    ) -> SharedArray

    Create a new SharedArray The callback function should return an array

    Socket

    source
    pub struct Socket {
      handle : 
    Any
    }

    WebSocket connection handle

    Socket::close

    source
    fn Socket::close(self : Socket) -> Unit

    Close WebSocket connection

    Socket::on

    source
    fn Socket::on(self : Socket, event : String, handler : 
    Any    ) -> Unit

    Set event handler for WebSocket events Events: "open", "message", "close", "error"

    Socket::send

    source
    fn Socket::send(self : Socket, data : String) -> Unit

    Send message to WebSocket server

    Socket::set_timeout

    source
    fn Socket::set_timeout(self : Socket, callback : () -> Unit, delay : Int) -> Unit

    Set timeout for WebSocket connection

    Stage

    source
    pub struct Stage {
      duration : String
      target : Int
    }

    Load test stage configuration

    Stage::new

    source
    fn Stage::new(duration : String, target : Int) -> Stage

    Create a new Stage

    Stage::to_js

    source
    fn Stage::to_js(self : Stage) -> 
    Any

    Convert Stage to JS object

    TagSet

    source
    pub struct TagSet {
      tags : Map[String, String]
    }

    Tag set for organizing test metrics

    TagSet::add

    source
    fn TagSet::add(self : TagSet, key : String, value : String) -> TagSet

    Add a tag

    TagSet::add_all

    source
    fn TagSet::add_all(self : TagSet, tags : Map[String, String]) -> TagSet

    Add multiple tags

    TagSet::get

    source
    fn TagSet::get(self : TagSet, key : String) -> String?

    Get tag value

    TagSet::new

    source
    fn TagSet::new() -> TagSet

    Create new tag set

    TagSet::remove

    source
    fn TagSet::remove(self : TagSet, key : String) -> TagSet

    Remove a tag

    TagSet::to_map

    source
    fn TagSet::to_map(self : TagSet) -> Map[String, String]

    Convert to map

    Test

    source
    pub struct Test {
      setup_data : 
    Any    ?
    }

    Create a test with setup and teardown

    Test::get_setup_data

    source
    fn Test::get_setup_data(self : Test) -> 
    Any    ?

    Get setup data

    Test::new

    source
    fn Test::new() -> Test

    Initialize test

    Test::set_setup_data

    source
    fn Test::set_setup_data(_self : Test, data : 
    Any    ) -> Test

    Set setup data

    TestConfig

    source
    pub struct TestConfig {
      setup_fn : () -> 
    Any    ?
      teardown_fn : (
    Any    ) -> Unit?
      vu_fn : (
    Any    ) -> Unit
    }

    Test configuration with lifecycle hooks

    TestConfig::new

    source
    fn TestConfig::new(vu_fn : (
    Any    ) -> Unit) -> TestConfig

    Create test config with only VU function

    TestConfig::setup

    source
    fn TestConfig::setup(self : TestConfig, setup_fn : () -> 
    Any    ) -> TestConfig

    Set setup function

    TestConfig::teardown

    source
    fn TestConfig::teardown(self : TestConfig, teardown_fn : (
    Any    ) -> Unit) -> TestConfig

    Set teardown function

    TestSetup

    source
    pub struct TestSetup {
      base_url : String?
      timeout : String?
      credentials : 
    Any    ?
      test_data : 
    Any    ?
    }

    Builder for test configuration

    TestSetup::base_url

    source
    fn TestSetup::base_url(self : TestSetup, url : String) -> TestSetup

    Set base URL

    TestSetup::build

    source

    Build setup data object

    TestSetup::credentials

    source
    fn TestSetup::credentials(self : TestSetup, username : String, password : String) -> TestSetup

    Set credentials

    TestSetup::new

    source
    fn TestSetup::new() -> TestSetup

    Create new test setup builder

    TestSetup::test_data

    source
    fn TestSetup::test_data(self : TestSetup, data : 
    Any    ) -> TestSetup

    Set test data

    TestSetup::timeout

    source
    fn TestSetup::timeout(self : TestSetup, timeout : String) -> TestSetup

    Set timeout

    Trend

    source
    pub struct Trend {
      name : String
      is_time : Bool
      handle : 
    Any
    }

    Trend metric - calculates statistics over added values

    Trend::add

    source
    fn Trend::add(self : Trend, value : Double) -> Unit

    Add a value to the trend

    Trend::add_value

    source
    fn Trend::add_value(self : Trend, value : Double) -> Unit

    Add value to trend

    Trend::new

    source
    fn Trend::new(name : String, is_time : Bool) -> Trend

    Create a new Trend metric

    WebSocketParams

    source
    pub struct WebSocketParams {
      headers : Map[String, String]?
      tags : Map[String, String]?
    }

    WebSocket connection parameters

    WebSocketParams::default

    source

    Create default WebSocket params

    WebSocketResponse

    source
    pub struct WebSocketResponse {
      url : String
      status : Int
      headers : 
    Any
    }

    WebSocket connection response

    add_to_shared_data

    source
    fn add_to_shared_data(data : 
    Any    , key : String, value : 
    Any    ) -> Unit

    Add value to shared data

    api_group

    source
    fn api_group(endpoint : String, body : () -> Unit) -> Unit

    Group for API calls

    auth_group

    source
    fn auth_group(body : () -> Unit) -> Unit

    Group for authentication

    b64decode

    source
    fn b64decode(input : String) -> String

    Decode base64 string

    b64decode_with_format

    source
    fn b64decode_with_format(input : String, encoding : String, format : String) -> String

    Decode base64 string with specific encoding and format encoding: "std" (standard) or "rawstd", "url" or "rawurl" format: "s" (string) or "b" (binary)

    b64encode

    source
    fn b64encode(input : String) -> String

    Encode string to base64

    b64encode_with_encoding

    source
    fn b64encode_with_encoding(input : String, encoding : String) -> String

    Encode string to base64 with specific encoding encoding: "std" (standard) or "rawstd", "url" or "rawurl"

    batch

    source

    Performs multiple HTTP requests in parallel Takes an array of request objects and returns an array of responses

    check

    source
    fn check(val : 
    Any    , checks : Map[String, (
    Any    ) -> Bool]) -> Bool

    Runs checks on values and returns whether all checks passed

    check_all

    source
    fn check_all(res : Response, checks_list : Array[(String, (Response) -> Bool)]) -> Bool

    Run multiple checks on a response

    check_body_contains

    source
    fn check_body_contains(res : Response, text : String) -> Bool

    Create a check for response body contains text

    check_equals

    source
    fn[T : Eq] check_equals(val : T, expected : T, name : String) -> Bool

    Check if value equals expected

    check_greater

    source
    fn[T : Compare + Eq] check_greater(val : T, threshold : T, name : String) -> Bool

    Check if value is greater than threshold

    check_less

    source
    fn[T : Compare + Eq] check_less(val : T, threshold : T, name : String) -> Bool

    Check if value is less than threshold

    check_response

    source
    fn check_response(res : Response, name : String, condition : (Response) -> Bool) -> Bool

    Check response with custom condition

    check_status

    source
    fn check_status(res : Response, expected : Int) -> Bool

    Create a check for HTTP response status

    check_status_200

    source
    fn check_status_200(res : Response) -> Bool

    Check if response status is 200

    check_status_201

    source
    fn check_status_201(res : Response) -> Bool

    Check if response status is 201

    check_status_204

    source
    fn check_status_204(res : Response) -> Bool

    Check if response status is 204

    check_status_400

    source
    fn check_status_400(res : Response) -> Bool

    Check if response status is 400

    check_status_404

    source
    fn check_status_404(res : Response) -> Bool

    Check if response status is 404

    check_status_500

    source
    fn check_status_500(res : Response) -> Bool

    Check if response status is 500

    check_status_ok

    source
    fn check_status_ok(res : Response) -> Bool

    Check if response status is 2xx (success)

    check_status_range

    source
    fn check_status_range(res : Response, min : Int, max : Int) -> Bool

    Create a check for HTTP response status in range

    check_value

    source
    fn[T] check_value(val : T, name : String, condition : (T) -> Bool) -> Bool

    Check any value with custom condition

    cleanup_group

    source
    fn cleanup_group(body : () -> Unit) -> Unit

    Group for cleanup operations

    cleanup_resources

    source
    fn cleanup_resources(_data : 
    Any    ) -> Unit

    Clean up resources in teardown

    connect

    source
    fn connect(url : String, params : WebSocketParams, callback : (Socket) -> Unit) -> WebSocketResponse

    Connect to WebSocket server The callback function receives a Socket object

    create_api_key_header

    source
    fn create_api_key_header(key : String) -> String

    Create API Key header value

    create_basic_auth_header

    source
    fn create_basic_auth_header(username : String, password : String) -> String

    Create Authorization header for Basic Auth

    create_bearer_auth_header

    source
    fn create_bearer_auth_header(token : String) -> String

    Create Authorization header for Bearer token

    create_counter

    source
    fn create_counter(name : String) -> Counter

    Create a simple counter metric

    create_gauge

    source
    fn create_gauge(name : String) -> Gauge

    Create a simple gauge metric

    create_hash

    source
    fn create_hash(algorithm : String) -> 
    Any

    Create a hash object algorithm: "md5", "sha1", "sha256", "sha384", "sha512", "sha512_256", "ripemd160"

    create_hmac

    source
    fn create_hmac(algorithm : String, secret : String) -> 
    Any

    Create an HMAC object algorithm: "md5", "sha1", "sha256", "sha384", "sha512", "sha512_256", "ripemd160"

    create_rate

    source
    fn create_rate(name : String) -> Rate

    Create a rate metric

    create_shared_data

    source
    fn create_shared_data() -> 
    Any

    Create shared data object for passing between lifecycle stages

    create_tagged_counter

    source
    fn create_tagged_counter(name : String, _tags : Map[String, String]) -> Counter

    Create counter with tags

    create_tagged_rate

    source
    fn create_tagged_rate(name : String, _tags : Map[String, String]) -> Rate

    Create rate with tags

    create_tagged_trend

    source
    fn create_tagged_trend(name : String, _tags : Map[String, String]) -> Trend

    Create trend with tags

    create_time_counter

    source
    fn create_time_counter(name : String) -> Counter

    Create a time counter metric (for duration measurements)

    create_time_gauge

    source
    fn create_time_gauge(name : String) -> Gauge

    Create a time gauge metric

    create_time_trend

    source
    fn create_time_trend(name : String) -> Trend

    Create a time trend metric (for duration measurements)

    create_trend

    source
    fn create_trend(name : String) -> Trend

    Create a trend metric

    current_iteration

    source
    fn current_iteration() -> Int

    Get current iteration number

    current_vu

    source
    fn current_vu() -> Int

    Get current VU ID

    db_group

    source
    fn db_group(name : String, body : () -> Unit) -> Unit

    Group for database operations

    delete

    source
    fn delete(url : String) -> Response

    Performs an HTTP DELETE request

    env

    source
    fn env(key : String) -> String?

    Get environment variable by name

    every_n_iterations

    source
    fn every_n_iterations(n : Int, f : () -> Unit) -> Unit

    Run code every N iterations

    execution_instance

    source
    fn execution_instance() -> 
    Any

    Get instance execution context Contains: vusActive, vusInitialized, iterationsCompleted, iterationsInterrupted

    execution_scenario

    source
    fn execution_scenario() -> 
    Any

    Get scenario execution context Contains: name, executor, startTime, progress, iterationInInstance, iterationInTest

    execution_vu

    source
    fn execution_vu() -> 
    Any

    Get VU execution context Contains: idInInstance, idInTest, iterationInInstance, iterationInScenario

    fail

    source
    fn fail(message : String) -> Unit

    Throws an error and aborts the current iteration

    get

    source
    fn get(url : String) -> Response

    Performs an HTTP GET request

    get_from_shared_data

    source
    fn get_from_shared_data(data : 
    Any    , key : String) -> 
    Any

    Get value from shared data

    get_with_params

    source
    fn get_with_params(url : String, params : 
    Any    ) -> Response

    Performs an HTTP GET request with parameters

    group

    source
    fn[T : Default] group(name : String, body : () -> T) -> T

    Executes code within a group context

    group_every_n_iterations

    source
    fn group_every_n_iterations(n : Int, name : String, body : () -> Unit) -> Unit

    Run group every N iterations

    group_on_first_iteration

    source
    fn group_on_first_iteration(name : String, body : () -> Unit) -> Unit

    Run group only on first iteration

    group_on_vu

    source
    fn group_on_vu(vu_id : Int, name : String, body : () -> Unit) -> Unit

    Run group only on specific VU

    http_group

    source
    fn http_group(name : String, body : () -> Unit) -> Unit

    Group for HTTP requests

    is_first_iteration

    source
    fn is_first_iteration() -> Bool

    Check if this is the first iteration

    is_iteration

    source
    fn is_iteration(n : Int) -> Bool

    Check if this is a specific iteration

    is_setup_phase

    source
    fn is_setup_phase() -> Bool

    Check if running in setup phase

    is_teardown_phase

    source
    fn is_teardown_phase() -> Bool

    Check if running in teardown phase

    is_vu

    source
    fn is_vu(n : Int) -> Bool

    Check if this is a specific VU

    is_vu_phase

    source
    fn is_vu_phase() -> Bool

    Check if running in VU phase

    iter

    source
    fn iter() -> Int

    Current iteration number (only available in VU context)

    iteration_in_instance

    source
    fn iteration_in_instance() -> Int

    Get iteration number in instance

    iteration_in_scenario

    source
    fn iteration_in_scenario() -> Int

    Get iteration number in scenario

    log_test_summary

    source
    fn log_test_summary(_data : 
    Any    ) -> Unit

    Log test summary in teardown

    md5

    source
    fn md5(data : String, output_encoding : String) -> String

    Calculate MD5 hash output_encoding: "hex", "base64", "base64url", "base64rawurl", "binary"

    measure_time

    source
    fn[T] measure_time(trend : Trend, f : () -> T) -> T

    Measure execution time of a function and record to trend

    measure_time_with_duration

    source
    fn[T] measure_time_with_duration(f : () -> T) -> (T, Double)

    Measure execution time and return both result and duration

    nested_group

    source
    fn[T : Default] nested_group(parent_name : String, child_name : String, body : () -> T) -> T

    Run nested groups with different tags

    on_first_iteration

    source
    fn on_first_iteration(f : () -> Unit) -> Unit

    Run code only on first iteration

    on_first_vu

    source
    fn on_first_vu(f : () -> Unit) -> Unit

    Run code only on first VU

    on_iteration

    source
    fn on_iteration(n : Int, f : () -> Unit) -> Unit

    Run code only on specific iteration

    on_vu

    source
    fn on_vu(n : Int, f : () -> Unit) -> Unit

    Run code only on specific VU

    open

    source
    fn open(filename : String) -> String

    Loads file content into memory (only available in init context)

    pace

    source
    fn pace(duration_seconds : Double) -> Unit

    Sleep for a specific duration in seconds

    pace_random

    source
    fn pace_random(min_seconds : Double, max_seconds : Double) -> Unit

    Sleep for a random duration between min and max seconds

    patch

    source
    fn patch(url : String, body : 
    Any    ) -> Response

    Performs an HTTP PATCH request

    post

    source
    fn post(url : String, body : 
    Any    ) -> Response

    Performs an HTTP POST request

    post_with_params

    source
    fn post_with_params(url : String, body : 
    Any    , params : 
    Any    ) -> Response

    Performs an HTTP POST request with parameters

    put

    source
    fn put(url : String, body : 
    Any    ) -> Response

    Performs an HTTP PUT request

    quick_delete

    source
    fn quick_delete(url : String) -> Response

    Quick DELETE request

    quick_get

    source
    fn quick_get(url : String) -> Response

    Quick GET request

    quick_patch_json

    source
    fn quick_patch_json(url : String, data : 
    Any    ) -> Response

    Quick PATCH request with JSON body

    quick_post_json

    source
    fn quick_post_json(url : String, data : 
    Any    ) -> Response

    Quick POST request with JSON body

    quick_put_json

    source
    fn quick_put_json(url : String, data : 
    Any    ) -> Response

    Quick PUT request with JSON body

    random_bytes

    source
    fn random_bytes(size : Int) -> 
    Any

    Generate random bytes

    random_seed

    source
    fn random_seed(seed : Int) -> Unit

    Sets the seed for reproducible pseudo-random number generation

    request

    source
    fn request(http_method : String, url : String, body : 
    Any    , params : Params) -> Response

    Performs a generic HTTP request

    request_oauth_token

    source
    fn request_oauth_token(token_url : String, client_id : String, client_secret : String) -> OAuthToken

    Request OAuth 2.0 token (Client Credentials flow)

    ripemd160

    source
    fn ripemd160(data : String, output_encoding : String) -> String

    Calculate RIPEMD160 hash output_encoding: "hex", "base64", "base64url", "base64rawurl", "binary"

    run_groups

    source
    fn run_groups(groups : Array[(String, () -> Unit)]) -> Unit

    Run multiple groups in sequence

    scenario_executor

    source
    fn scenario_executor() -> String

    Get scenario executor

    scenario_info

    source
    fn scenario_info() -> 
    Any

    Get scenario information

    scenario_name

    source
    fn scenario_name() -> String

    Get scenario name

    scenario_progress

    source
    fn scenario_progress() -> Double

    Get scenario progress (0.0 to 1.0)

    setup_database

    source
    fn setup_database() -> 
    Any

    Example: Setup database connection

    setup_group

    source
    fn setup_group(body : () -> Unit) -> Unit

    Group for setup operations

    setup_http_config

    source
    fn setup_http_config() -> 
    Any

    Setup HTTP client configuration

    setup_test_data_from_file

    source
    fn setup_test_data_from_file(filename : String) -> 
    Any

    Setup test data from file

    setup_test_urls

    source
    fn setup_test_urls(base_url : String) -> 
    Any

    Setup test URLs

    sha1

    source
    fn sha1(data : String, output_encoding : String) -> String

    Calculate SHA1 hash output_encoding: "hex", "base64", "base64url", "base64rawurl", "binary"

    sha256

    source
    fn sha256(data : String, output_encoding : String) -> String

    Calculate SHA256 hash output_encoding: "hex", "base64", "base64url", "base64rawurl", "binary"

    sha384

    source
    fn sha384(data : String, output_encoding : String) -> String

    Calculate SHA384 hash output_encoding: "hex", "base64", "base64url", "base64rawurl", "binary"

    sha512

    source
    fn sha512(data : String, output_encoding : String) -> String

    Calculate SHA512 hash output_encoding: "hex", "base64", "base64url", "base64rawurl", "binary"

    sha512_256

    source
    fn sha512_256(data : String, output_encoding : String) -> String

    Calculate SHA512/256 hash output_encoding: "hex", "base64", "base64url", "base64rawurl", "binary"

    sleep

    source
    fn sleep(duration : Double) -> Unit

    Pauses VU execution for the specified duration in seconds

    tag_api_version

    source
    fn tag_api_version(version : String) -> (String, String)

    Create API version tag

    tag_environment

    source
    fn tag_environment(env : String) -> (String, String)

    Create environment tag

    tag_region

    source
    fn tag_region(region : String) -> (String, String)

    Create region tag

    tag_scenario

    source
    fn tag_scenario(scenario : String) -> (String, String)

    Create scenario tag

    tag_test_type

    source
    fn tag_test_type(test_type : String) -> (String, String)

    Create test type tag

    tag_user_type

    source
    fn tag_user_type(user_type : String) -> (String, String)

    Create user type tag

    tagged_group_request

    source
    fn tagged_group_request(group_name : String, builder : RequestBuilder, tags : Map[String, String]) -> Response

    Execute request in tagged group

    tagged_request

    source
    fn tagged_request(builder : RequestBuilder, tags : Map[String, String]) -> Response

    Execute request with tags

    teardown_database

    source
    fn teardown_database(_data : 
    Any    ) -> Unit

    Example: Teardown database connection

    test_auth_required

    source
    fn test_auth_required(url : String) -> Bool

    Test if authentication is required

    test_auth_valid

    source
    fn test_auth_valid(url : String, session : AuthSession) -> Bool

    Test if authentication is valid

    test_basic_auth

    source
    fn test_basic_auth(url : String, username : String, password : String) -> Bool

    Test Basic Auth credentials

    test_bearer_token

    source
    fn test_bearer_token(url : String, token : String) -> Bool

    Test Bearer token

    test_info

    source
    fn test_info() -> 
    Any

    Get test execution context Contains: options, abort()

    test_info_data

    source
    fn test_info_data() -> 
    Any

    Get test information

    think

    source
    fn think(duration_seconds : Double) -> Unit

    Simulate user think time (alias for sleep)

    think_random

    source
    fn think_random(min_seconds : Double, max_seconds : Double) -> Unit

    Think time between min and max seconds

    track_http_count

    source
    fn track_http_count(counter : Counter) -> Unit

    Track HTTP request count

    track_http_duration

    source
    fn track_http_duration(_name : String, _res : Response, trend : Trend) -> Unit

    Track HTTP request duration

    track_http_success

    source
    fn track_http_success(rate : Rate, res : Response) -> Unit

    Track success rate based on HTTP status
    fn vu() -> Int

    Current VU number (only available in VU context)

    vu_id_in_instance

    source
    fn vu_id_in_instance() -> Int

    Get VU ID in instance

    vu_id_in_test

    source
    fn vu_id_in_test() -> Int

    Get VU ID in test

    vu_info

    source
    fn vu_info() -> 
    Any

    Get VU information

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io