Struct ExpectArray 

pub struct ExpectArray { /* private fields */ }

Implementations

impl ExpectArray

pub fn empty(self) -> Self

pub fn not_empty(self) -> Self

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

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

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

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

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

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

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) -> Self

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(&json!(expect_json::array().all(
        json!({
            "name": expect_json::string().not_empty(),
            "email": expect_json::email(),
        })
    )));

pub fn unique(self) -> Self

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

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<Self, __D::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], ) -> ExpectOpResult<()>

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, ) -> ExpectOpResult<()>

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

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

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

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

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

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

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

impl From<ExpectArray> for Value

fn from(value: ExpectArray) -> Self

Converts to this type from the input type.

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::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExpectArray