Struct ExpectArray 

pub struct ExpectArray { /* private fields */ }

Implementations

impl ExpectArray

pub fn empty(self) -> ExpectArray

pub fn not_empty(self) -> ExpectArray

pub fn len(self, len: usize) -> ExpectArray

pub fn min_len(self, min_len: usize) -> ExpectArray

pub fn max_len(self, max_len: usize) -> ExpectArray

pub fn contains<I, V>(self, expected_values: I) -> ExpectArray

where I: IntoIterator<Item = V>, V: Into<Value>,

pub fn eq_unordered<I, V>(self, expected_values: I) -> ExpectArray

where I: IntoIterator<Item = V>, V: Into<Value>,

Expects all values in the array match the expected values in some order. This can be an exact value, or an ExpectOp. The lengths of the arrays must be equal.

pub fn all<V>(self, expected: V) -> ExpectArray

where V: Into<Value>,

Expects all values in the array match the expected value. This can be an exact value, or an ExpectOp.

Note an empty array will match this.

use axum_test::expect_json;

let server = TestServer::new(Router::new());

server.get(&"/users")
    .await
    .assert_json(&expect_json::array().all(
        json!({
            "name": expect_json::string().not_empty(),
            "email": expect_json::email(),
        })
    ));

pub fn all_contains<V>(self, expected: V) -> ExpectArray

where V: Into<Value>,

Expects all values to be an object, containing the expected value.

Example Usage

use axum_test::expect_json;

let server = TestServer::new(Router::new());

server.get(&"/users")
    .await
    .assert_json(&expect_json::array().all_contains(json!({
        "name": expect_json::string().not_empty(),
        "email": expect_json::email(),
    })));

Equivalent Usage

This is shorthand for using ExpectArray::all and ExpectObject::contains, like so:

use axum_test::expect_json;

let server = TestServer::new(Router::new());

server.get(&"/users")
    .await
    .assert_json(&expect_json::array().all(
        expect_json::object().contains(json!({
            "name": expect_json::string().not_empty(),
            "email": expect_json::email(),
        }))
    ));

pub fn unique(self) -> ExpectArray

Expects all values in the array are unique. No duplicates.

use axum_test::expect_json;

let server = TestServer::new(Router::new());

server.get(&"/users")
    .await
    .assert_json(&json!({
        // expect an array of unique UUIDs
        "user_ids": expect_json::array()
            .all(expect_json::uuid())
            .unique(),
    }));

Trait Implementations

impl Clone for ExpectArray

fn clone(&self) -> ExpectArray

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExpectArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for ExpectArray

fn default() -> ExpectArray

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExpectArray

fn deserialize<__D>( __deserializer: __D, ) -> Result<ExpectArray, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ExpectOp for ExpectArray

fn on_array( &self, context: &mut Context<'_>, received: &[Value], ) -> Result<(), ExpectOpError>

fn debug_supported_types(&self) -> &'static [JsonType]

This is optional to implement. This method returns a list of types this is targeting.

fn on_any( &self, context: &mut Context<'_>, received: &Value, ) -> Result<(), ExpectOpError>

fn on_null(&self, context: &mut Context<'_>) -> Result<(), ExpectOpError>

fn on_f64( &self, context: &mut Context<'_>, received: f64, ) -> Result<(), ExpectOpError>

fn on_u64( &self, context: &mut Context<'_>, received: u64, ) -> Result<(), ExpectOpError>

fn on_i64( &self, context: &mut Context<'_>, received: i64, ) -> Result<(), ExpectOpError>

fn on_boolean( &self, context: &mut Context<'_>, received: bool, ) -> Result<(), ExpectOpError>

fn on_string( &self, context: &mut Context<'_>, received: &str, ) -> Result<(), ExpectOpError>

fn on_object( &self, context: &mut Context<'_>, received: &Map<String, Value>, ) -> Result<(), ExpectOpError>

impl PartialEq for ExpectArray

fn eq(&self, other: &ExpectArray) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExpectArray

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExpectArray