Drill is an HTTP load testing application written in Rust inspired by Ansible syntax

Overview

Drill

Drill is a HTTP load testing application written in Rust. The main goal for this project is to build a really lightweight tool as alternative to other that require JVM and other stuff.

You can write benchmark files, in YAML format, describing all the stuff you want to test.

It was inspired by Ansible syntax because it is really easy to use and extend.

Here is an example for benchmark.yml:

---

concurrency: 4
base: 'http://localhost:9000'
iterations: 5
rampup: 2

plan:
  - name: Include comments
    include: comments.yml

  - name: Fetch users
    request:
      url: /api/users.json

  - name: Fetch organizations
    request:
      url: /api/organizations

  - name: Fetch account
    request:
      url: /api/account
    assign: foo

  - name: Fetch manager user
    request:
      url: /api/users/{{ foo.body.manager_id }}

  - name: Assign values
    assign:
      key: bar
      value: "2"

  - name: Assert values
    assert:
      key: bar
      value: "2"

  - name: Fetch user from assign
    request:
      url: /api/users/{{ bar }}

  - name: Fetch some users
    request:
      url: /api/users/{{ item }}
    with_items:
      - 70
      - 73
      - 75

  - name: Fetch some users by hash
    request:
      url: /api/users/{{ item.id }}
    with_items:
      - { id: 70 }
      - { id: 73 }
      - { id: 75 }

  - name: Fetch some users by range, index {{ index }}
    request:
      url: /api/users/{{ item }}
    with_items_range:
      start: 70
      step: 5
      stop: 75

  - name: Fetch some users from CSV, index {{ index }}
    request:
      url: /api/users/contacts/{{ item.id }}
    with_items_from_csv: ./fixtures/users.csv
    shuffle: true

  - name: POST some crafted JSONs stored in CSV, index {{ index }}
    request:
      url: /api/transactions
      method: POST
      body: '{{ item.txn }}'
      headers:
        Content-Type: 'application/json'
    with_items_from_csv:
      file_name: ./fixtures/transactions.csv
      quote_char: "\'"

  - name: Fetch no relative url
    request:
      url: http://localhost:9000/api/users.json

  - name: Interpolate environment variables
    request:
      url: http://localhost:9000/api/{{ EDITOR }}

  - name: Support for POST method
    request:
      url: /api/users
      method: POST
      body: foo=bar&arg={{ bar }}

  - name: Login user
    request:
      url: /login?user=example&password=3x4mpl3

  - name: Fetch counter
    request:
      url: /counter
    assign: memory

  - name: Fetch counter
    request:
      url: /counter
    assign: memory

  - name: Fetch endpoint
    request:
      url: /?counter={{ memory.body.counter }}

  - name: Reset counter
    request:
      method: DELETE
      url: /

  - name: Exec external commands
    exec:
      command: "echo '{{ foo.body }}' | jq .phones[0] | tr -d '\"'"
    assign: baz

  - name: Custom headers
    request:
      url: /admin
      headers:
        Authorization: Basic aHR0cHdhdGNoOmY=
        X-Foo: Bar
        X-Bar: Bar {{ memory.headers.token }}

As you can see, you can play with interpolations in different ways. This will let you specify a benchmark with different requests and dependencies between them.

If you want to know more about the benchmark file syntax, read this

Install

The easiest way right now is to install with cargo:

cargo install drill
drill --benchmark benchmark.yml --stats

or download the source code and compile it:

git clone [email protected]:fcsonline/drill.git && cd drill
cargo build --release
./target/release/drill --benchmark benchmark.yml --stats

Note: You will need to install libssl-dev and pkg-config packages.

Demo

demo

Features

This is the list of all features supported by the current version of drill:

  • Concurrency: run your benchmarks choosing the number of concurrent iterations.
  • Multi iterations: specify the number of iterations you want to run the benchmark.
  • Ramp-up: specify the amount of time it will take drill to start all iterations.
  • Delay: introduce controlled delay between requests. Example: delay.yml
  • Dynamic urls: execute requests with dynamic interpolations in the url, like /api/users/{{ item }}
  • Dynamic headers: execute requests with dynamic headers. Example: headers.yml
  • Interpolate environment variables: set environment variables, like /api/users/{{ EDITOR }}
  • Executions: execute remote commands with test plan data.
  • Assertions: assert values during the test plan. Example: iterations.yml
  • Request dependencies: create dependencies between requests with assign and url interpolations.
  • Split files: organize your benchmarks in multiple files and include them.
  • CSV support: read CSV files and build N requests fill dynamic interpolations with CSV data.
  • HTTP methods: build request with different http methods like GET, POST, PUT, PATCH, HEAD or DELETE.
  • Cookie support: create benchmarks with sessions because cookies are propagates between requests.
  • Stats: get nice statistics about all the requests. Example: cookies.yml
  • Thresholds: compare the current benchmark performance against a stored one session and fail if a threshold is exceeded.

Test it

Go to the example directory and you'll find a README how to test it in a safe environment.

Disclaimer: We really recommend not to run intensive benchmarks against production environments.

Command line interface

Full list of cli options, which is available under drill --help

drill 0.7.1
HTTP load testing application written in Rust inspired by Ansible syntax

USAGE:
    drill [FLAGS] [OPTIONS] --benchmark 
   
    

FLAGS:
    -h, --help                      Prints help information
    -n, --nanosec                   Shows statistics in nanoseconds
        --no-check-certificate      Disables SSL certification check. (Not recommended)
    -q, --quiet                     Disables output
        --relaxed-interpolations    Do not panic if an interpolation is not present. (Not recommended)
    -s, --stats                     Shows request statistics
    -V, --version                   Prints version information
    -v, --verbose                   Toogle verbose output

OPTIONS:
    -b, --benchmark 
    
         Sets the benchmark file
    -c, --compare 
     
              Sets a compare file
    -r, --report 
      
                 Sets a report file
    -t, --threshold 
       
         Sets a threshold value in ms amongst the compared file -o, --timeout 
        
          Set timeout in seconds for all requests 
        
       
      
     
    
   

Roadmap

  • Complete and improve the interpolation engine
  • Add writing to a file support

Contribute

This project started as a side project to learn Rust, so I'm sure that is full of mistakes and areas to be improve. If you think you can tweak the code to make it better, I'll really appreciate a pull request. ;)

Comments
  • Strip characters like double quotes in 'assign' JSON response values

    Strip characters like double quotes in 'assign' JSON response values

    Hi guys, not sure if there's a workaround for this current issue.

    I have a thread test suite that first posts to an endpoint /token, and assigns the response value. I want to get one attribute and pass it in as the token value in subsequent request headers, like this:

    GET /users/3472742
    Headers:
      Bearer as897c98webjk324jkfds9
    

    Instead, when I pass in this assign response attribute using {{ response.token }}, I get hard coded double quotes that break this request:

    GET /users/3472742
    Headers:
      Bearer "as897c98webjk324jkfds9"
    

    Is there any way in Drill to strip characters like these from JSON response values?

    opened by patrick-armitage 14
  • Introducing concurrency configuration

    Introducing concurrency configuration

    When using async, you don't need lots of threads to achieve more concurrency.

    10 threads 10 concurrency:

    Threads 10
    Iterations 1000
    Rampup 0
    Base URL http://localhost:9000
    
    
    Fetch users               Total requests            10000
    Fetch users               Successful requests       10000
    Fetch users               Failed requests           0
    Fetch users               Median time per request   2ms
    Fetch users               Average time per request  2ms
    Fetch users               Sample standard deviation 1ms
    
    Concurrency Level         10
    Time taken for tests      2.0 seconds
    Total requests            10000
    Successful requests       10000
    Failed requests           0
    Requests per second       5010.52 [#/sec]
    Median time per request   2ms
    Average time per request  2ms
    Sample standard deviation 1ms
    

    10 threads 50 concurrency:

    Threads 10
    Iterations 1000
    Rampup 0
    Base URL http://localhost:9000
    
    
    Fetch users               Total requests            50000
    Fetch users               Successful requests       50000
    Fetch users               Failed requests           0
    Fetch users               Median time per request   5ms
    Fetch users               Average time per request  5ms
    Fetch users               Sample standard deviation 2ms
    
    Concurrency Level         50
    Time taken for tests      5.1 seconds
    Total requests            50000
    Successful requests       50000
    Failed requests           0
    Requests per second       9792.15 [#/sec]
    Median time per request   5ms
    Average time per request  5ms
    Sample standard deviation 2ms
    
    opened by messense 7
  • Concurrency and randomness for with_items

    Concurrency and randomness for with_items

    I was testing drill with a large CSV file of different item IDs. Is there any supported way to randomize the execution order? Right now this means that my concurrency is basically lock-step requesting the same items in the same order which maximizes the benefits from caching. It'd be really nice if there was a way to have the order be randomized other than, say, running multiple instances scripting shuf on a CSV file for each one.

    enhancement 
    opened by acdha 6
  • RFC - Verbose Flag

    RFC - Verbose Flag

    I really miss some kind of flag to show more information about request/response

    I've been learning Rust last year and it's a feature I could implement myself if you guys find it interesting :+1:

    enhancement 
    opened by jrabello 6
  • POST-ing a sequence of JSON objects in Drill

    POST-ing a sequence of JSON objects in Drill

    The task I'd like to perform with Drill is to have it read a csv file filled with JSON objects representing a transaction (txn) and have it POST to an address with the JSON being the body of the transaction. I've been unsuccessful.

    Here is what a simplified yml file looks like

    ---
    
    threads: 1
    base: 'http://localhost:8669'
    iterations: 1
    rampup: 2
    
    plan:
      - name: POST transactions to standalone ledger from CSV
        request:
          url: /submit_transaction
          method: POST
          body: {{ item.txn }}
          headers:
            Content-Type: 'application/json'
        with_items_from_csv:
          file_name: ./log.csv
          quote_char: "\'"
    

    and the log.csv file looks like:

    txn
    '{"operations": [{"DefineAsset": {"body": {"asset": {"code": {"val":
    [114, 255, 1, 164, 16, 58, 220, 131, 26, 36, 233, 7, 83, 132, 2,
    250]}, "issuer": {"key":
    "RkcRIKYXs_t2CKgxFwLc2AMCKOQP2N0Q3kTuIVIbCII="}, "memo": "",
    "confidential_memo": null, "updatable": false, "traceable": false}},
    "pubkey": {"key": "RkcRIKYXs_t2CKgxFwLc2AMCKOQP2N0Q3kTuIVIbCII="},
    "signature": "b6gc3THsoVFlBlMSUP78IxwPY37c2k-yllJJMtLhc1FW0iko0jSlSOBfjzMbPLdfsE7Dt2ky8ZsxKR9JTMvFAw=="}}],
    "credentials": [], "memos": []}'
    

    What appears to be happening is that the POST occurs with an empty body, suggesting that the interpolation of the JSON into the body has gone wrong, or I've used the wrong syntax. Any ideas?

    opened by bpr 6
  • terminal colours not working on windows outside `cargo run`

    terminal colours not working on windows outside `cargo run`

    I tried building and using drill on Windows, with cargo install, for a particular client where I needed to use their SoE desktop in a quick project.

    The colour-printing code didn't work right; I got ANSI escape codes printed literally on the terminal. This was running in VScode, with either powershell or git bash. I got the same in the powershell gui window. I set CLICOLOR=0 and got on with the task, but I wanted to come back and fix the problem so I could leave them with a working setup.

    I then cloned the repo, but to my surprise cargo run showed the colours correctly. Invoking the same executable from target/release/drill.exe printed ANSI codes again!

    The windows console doesn't interpret ANSI codes by defaut, and needs a console API call to set it into the appropriate mode. It turns out, cargo uses this mode, and leaves it active when invoking the program via cargo run.

    The below patch fixes, or at least works around the problem.

    diff --git a/src/main.rs b/src/main.rs
    index 2164af2..3db592b 100644
    --- a/src/main.rs
    +++ b/src/main.rs
    @@ -35,6 +35,8 @@ fn main() {
       let no_check_certificate = matches.is_present("no-check-certificate");
       let quiet = matches.is_present("quiet");
       let nanosec = matches.is_present("nanosec");
    +  #[cfg(windows)]
    +  let _ = control::set_virtual_terminal(true);
     
       let begin = time::precise_time_s();
       let list_reports_result = benchmark::execute(benchmark_file, report_path_option, no_check_certificate, quiet, nanosec);
    

    Note: I'm a very infrequent Windows user, and this was my first time trying Rust on Windows. Unfortunately I didn't have a chance to fully test this change in all combinations while on site, so it might still misbehave in the case of redirected output or some other situation. See the comments at the top of https://github.com/mackwic/colored/blob/master/src/control.rs for more detail; there may be more that needs to be done to properly set up the windows console. That's one reason I've given a code example as a diff rather than a PR.

    Big hat-tip to @retep998 for pointing out the console-mode api, I was well down the wrong rabbit-hole looking at differences in other environment variables between the two invocation methods.

    opened by dcarosone 6
  • Allow for environment variables to be interpolated with test plans

    Allow for environment variables to be interpolated with test plans

    It would be really neat if we could add environment variables to the yaml plans.

    For example you could export some vars:

    $ export BASE_URL='http://localhost:8000'
    $ export CONCURRENCY=50
    $ export ITERATIONS=100
    

    and in the yaml plan make it look at the ENV vars:

    ---
    
    concurrency: {{ $CONCURRENCY }} 
    base: {{ $BASE_URL }}
    iterations: {{ $ITERATIONS }}
    
    plan:
      - name: homepage
        request:
          url: /
    
    opened by Stii 5
  • Programmatic API

    Programmatic API

    YAML is a configuration language, not a programming language. While writing tests, sometimes I want the power of a programming language.

    For example, I'd like to be able to POST n transactions to a URL, followed by a different specific POST to get a batching (with a factor of n) interface. This kind of thing is trivial to do in Locust but is harder to do without a programmatic API.

    I doubt that replacing the YAML front end with a different embedded language is something that appeals to the Drill community. Since I already work in Rust, I'd like it if some of the internals of Drill were opened up and enhanced so that I could write some of my tests in Rust, using Drill.

    opened by bpr 5
  • Question: how to pass a large payload to request body

    Question: how to pass a large payload to request body

    Hi again!

    I am trying to pass a large payload to a PUT request

    I trying converting to YAML and putting into the body but when my target API is called, it does not receive any body

    here is my scenario:

    ---
    threads: 1
    base: 'http://localhost:8080'
    iterations: 1
    
    plan:
      - name: Update Configuration
        request:
          url: /api/channel/v1/custom/integration/configurations/xyz
          method: PUT
          headers:
            Cookie: "{{ authCookie }}"
            Content-Type: "application/json"
          body:
            domainValidateEndpoint: http://localhost:3000
            crestBaseConfiguration:
              host: http://localhost:3000
              azureHost: http://localhost:3000
              azureManagementHost: http://localhost:3000
              azureResource: http://localhost:3000
              partnerBillingDay: 1
              partnerCenterApiHost: https://api.partnercenter.microsoft.com
              partnerCenterAuthHost: https://login.windows.net
              partnerCenterResource: https://api.partnercenter.microsoft.com
              azureProvisioningDelayInMinutes: 180
              credentialsSetupStep: COMPLETED
              apiSetupStep: COMPLETED
              apiAuthorizationStep: COMPLETED
              configuredByAppDirect: false
              crestConfigurations:
                USA:
                  azureConfig:
                    clientId: someId
                    clientSecret: someSecret
                    managementUsername: [email protected]
                    managementPassword: someSecret
                    grantType: PASSWORD
                    encrypted: false
                  partnerCenterConfiguration:
                    clientId: 6c9f572a-d69a-4e08-b4e5-194696492374
                    applicationDomain: dummy.onmicrosoft.com
                  resellerCaid: 6c9f572a-d69a-4e08-b4e5-194696492374
                  resellerDomain: dummy.onmicrosoft.com
                  resellerPurchaseEnabled: true
              cspAzureConfigValid: true
            mosiEnabled: false
            crestEnabled: true
            azureEnabled: true
    
    opened by picaron 5
  • Add a

    Add a "pick" option for requests

    Resolves #131

    Allows to pick a subset of items from with_items.
    Pick limits the amount of requests done instead of doing one for each item.
    When used in conjunction with shuffle, it can be used to send one request with a random item from the list.

    - name: One request with a random item
      request:
        url: /api/users/{{ item }}
      with_items:
        - 70
        - 73
        - 75
      shuffle: true
      pick: 1
    
    opened by hendric-dev 4
  • Assign response code for assertions

    Assign response code for assertions

    It would be great to be able to assert response codes in assertions, the same way as it is currently done with headers and body.

    For example

    plan:
      - name: Healthcheck
        request:
          url: /healthcheck
        assign: healthcheck
    
      - name: Healtchcheck status assertion
        assert:
          key: "healthcheck.response_code"
          value: "200"
    
    opened by puls-com-leon-komarovsky 4
  • Bump tokio from 1.23.0 to 1.23.1

    Bump tokio from 1.23.0 to 1.23.1

    Bumps tokio from 1.23.0 to 1.23.1.

    Release notes

    Sourced from tokio's releases.

    Tokio v1.23.1

    This release forward ports changes from 1.18.4.

    Fixed

    • net: fix Windows named pipe server builder to maintain option when toggling pipe mode (#5336).

    #5336: tokio-rs/tokio#5336

    Commits
    • 1a997ff chore: prepare Tokio v1.23.1 release
    • a8fe333 Merge branch 'tokio-1.20.x' into tokio-1.23.x
    • ba81945 chore: prepare Tokio 1.20.3 release
    • 763bdc9 ci: run WASI tasks using latest Rust
    • 9f98535 Merge remote-tracking branch 'origin/tokio-1.18.x' into fix-named-pipes-1.20
    • 9241c3e chore: prepare Tokio v1.18.4 release
    • 699573d net: fix named pipes server configuration builder
    • See full diff in compare view

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies rust 
    opened by dependabot[bot] 0
  • Added ability to set default headers and to copy headers

    Added ability to set default headers and to copy headers

    Added some code to be able to both set default headers for a benchmark, as well as copy headers from the response of one request to use for future requests (mainly implemented to be help me deal with CSRF tokens). This is my first PR for a rust project, so let me know if there's anything that might need changes.

    As far as I can tell, these changes didn't break anything when running either cargo test or the benchmark.yml benchmark. I also added a bit of code to the example server and the headers.yml benchmark to test the new functionality.

    opened by shadowwolf899 1
  • Print a message if a newer version is available

    Print a message if a newer version is available

    Hi there!

    I found this feature very useful in the GitHub CLI application and npm.

    I think it'll be useful for users who install drill using cargo. And this will let them know that a new version is available and it's time to update.

    Ready-made crates to do that:

    • https://github.com/mgrachev/update-informer
    • https://github.com/tarikeshaq/update-notifier
    opened by nobsaibot 0
  • fix: increase maximum bounds of histogram

    fix: increase maximum bounds of histogram

    Currently, the maximum bounds of 60*60*1000 is insufficient for requests that take longer than ~4000ms. Increasing the bounds of this by a factor of 10 should prevent this ever being an issue for long requests.

    opened by Mythral 0
  • RUSTSEC-2021-0139: ansi_term is Unmaintained

    RUSTSEC-2021-0139: ansi_term is Unmaintained

    ansi_term is Unmaintained

    | Details | | | ------------------- | ---------------------------------------------- | | Status | unmaintained | | Package | ansi_term | | Version | 0.12.1 | | URL | https://github.com/ogham/rust-ansi-term/issues/72 | | Date | 2021-08-18 |

    The maintainer has adviced this crate is deprecated and will not receive any maintenance.

    The crate does not seem to have much dependencies and may or may not be ok to use as-is.

    Last release seems to have been three years ago.

    Possible Alternative(s)

    The below list has not been vetted in any way and may or may not contain alternatives;

    See advisory page for additional details.

    opened by github-actions[bot] 0
Releases(0.8.1)
  • 0.8.0(Jul 10, 2022)

    :gift: New features

    • Improved documentation. Thanks to @corrieriluca (https://github.com/fcsonline/drill/pull/118)
    • Integrate High Dynamic Range Histogram. Thanks to @schrieveslaach (https://github.com/fcsonline/drill/pull/120)
    • Read items from file lines. Thanks to @SteVio89 (https://github.com/fcsonline/drill/pull/127)
    • Add step filtering by tags. Thanks to @IvashchenkoSerhii (https://github.com/fcsonline/drill/pull/132)
    • Add response status code into request assignations
    • Convert Travis configuration into Github Actions
    • Updated many outdated dependencies
    Source code(tar.gz)
    Source code(zip)
  • 0.7.2(Sep 3, 2021)

    • Add shuffle feature to with_items
    • Fix body for put and patch verbs
    • Add index variable for loop actions
    • Panic for properties that don't support interpolations
    • Fix Windows console colors code support
    • Fix command-line option to set timeout in seconds
    • New actions: Assert values
    • Add flag for verbose output
    • New Action: Execute OS commands
    Source code(tar.gz)
    Source code(zip)
  • 0.7.0(Nov 27, 2020)

    • Migration Async / Await completed!
    • New concurrency model
    • Interpolate env variables
    • Added Keep-Alive
    • Request headers memory
    • New delay actions
    Source code(tar.gz)
    Source code(zip)
  • 0.6.0(May 23, 2020)

    • Fixed quotes in string fields and panic on HTTP errors
    • Support multiple cookies
    • Fix wrong behavior for 1 iteration
    • Improve general performance
    • Fixed issues with interpolations
    • Relaxed interpolations
    • Add more documentation
    Source code(tar.gz)
    Source code(zip)
  • 0.5.0(Mar 20, 2019)

    • Added rampup option
    • Added HEAD verb support
    • Added new option with_items_range
    • Improved stats
    • New CSV parsing options
    • New no-check-certificate option to ingore SSL certificate validation
    • Formatted code with rustfmt
    Source code(tar.gz)
    Source code(zip)
  • 0.4.0(Nov 8, 2018)

    • Fixed concurrency issue
    • Fixed interpolation issue
    • Added new available interpolations: {{ thread }} and {{ iteration }}
    • Added new server to test low connections
    • More colors in log
    Source code(tar.gz)
    Source code(zip)
  • 0.3.5(Mar 8, 2018)

  • 0.3.2(Mar 8, 2018)

  • 0.3.1(Mar 8, 2018)

Owner
Ferran Basora
We need a tool™
Ferran Basora
Handle some lichess.org/tournament load with Rust, while learning Rust

lila-http Take some of the HTTP load away from lila. WIP! Arena tournaments Clients connected to a tournament page request new data about the tourname

Lichess 22 Jan 2, 2023
Testing Framework for Rust

Polish Polish is Test-Driven Development done right Getting Started Installing the Package The crates.io package is kept up-to-date with all the major

Fadi Hanna Al-Kass 49 Dec 18, 2022
ArchTest is a rule based architecture testing tool for rust

ArchTest is a rule based architecture testing tool. It applies static analyses on the specified rust project to extract use relationships.

Tom Dymel 7 Sep 26, 2021
Automated property based testing for Rust (with shrinking).

quickcheck QuickCheck is a way to do property based testing using randomly generated input. This crate comes with the ability to randomly generate and

Andrew Gallant 2k Jan 2, 2023
Hypothesis-like property testing for Rust

Proptest Introduction Proptest is a property testing framework (i.e., the QuickCheck family) inspired by the Hypothesis framework for Python. It allow

Jason Lingle 1.1k Jan 1, 2023
Simple goldenfile testing in Rust.

?? Rust Goldenfile Simple goldenfile testing in Rust. Goldenfile tests generate one or more output files as they run. At the end of the test, the gene

Calder Coalson 24 Nov 26, 2022
Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.

An implementation of the Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.

Brendan Molloy 394 Jan 1, 2023
Loom is a concurrency permutation testing tool for Rust.

Loom is a testing tool for concurrent Rust code

Tokio 1.4k Jan 9, 2023
assay - A super powered testing macro for Rust

assay - A super powered testing macro for Rust as·say /ˈaˌsā,aˈsā/ noun - the testing of a metal or ore to determine its ingredients and quality. Rust

Michael Gattozzi 105 Dec 4, 2022
Rust testing library

K9 - Rust Testing Library Snapshot testing + better assertions Available test macros snapshot assert_equal assert_greater_than assert_greater_than_or_

Aaron Abramov 269 Dec 10, 2022
Testing Framework for Rust

Polish Polish is Test-Driven Development done right Getting Started Installing the Package The crates.io package is kept up-to-date with all the major

Fadi Hanna Al-Kass 49 Dec 18, 2022
Rustress - stress testing library in Rust. For fun

rustress Simple network stress testing library. To get familiar with Rust Planned features (Subject to change) Multithreaded client/server Throughput

Hakan Sönmez 7 Sep 22, 2022
insta: a snapshot testing library for Rust

insta: a snapshot testing library for Rust Introduction Snapshots tests (also sometimes called approval tests) are tests that assert values against a

Armin Ronacher 1.4k Jan 1, 2023
Verdun is a HTTP stress-test/benchmark tool written in Rust.

Verdun is a HTTP stress-test/benchmark tool written in Rust. ?? It supports testing a single URL, loading multiples URLs from a file or automatically navigating a website (auto discovery)

Alex Hortopan 2 Feb 23, 2022
Rnp - A simple cloud-friendly tool for testing network reachability.

Rnp - A simple cloud-friendly tool for testing network reachability. Release Status Crates.io Github release Nuget packages NOTE: This project is in e

Riff 50 Dec 13, 2022
Simple assertion library for unit testing in python with a fluent API

Simple assertions library for unit testing in Python with a nice fluent API. Supports both Python 2 and 3.

snakedye 19 Sep 10, 2022
Viceroy provides local testing for developers working with [email protected]

Viceroy provides local testing for developers working with [email protected] It allows you to run services written against the [email protected] APIs on your local development machine, and allows you to configure testing backends for your service to communicate with.

Fastly 99 Jan 7, 2023
Declarative Testing Framework

Demonstrate allows tests to be written without as a much repetitive code within the demonstrate! macro, which will generate the corresponding full tests.

Austin Baugh 41 Aug 17, 2022
🧵 Generate self-describing strings of a given length to help aid software testing

rust-counter-strings Counter strings generator written in rust to help aid software testing What is a counterstring? "A counterstring is a graduated s

Thomas Chaplin 23 Jun 24, 2022