Struct TestCaseConfigBuilder 

pub struct TestCaseConfigBuilder<S: State = Empty> { /* private fields */ }

Use builder syntax to set the inputs and finish with build_internal().

Implementations

impl<S: State> TestCaseConfigBuilder<S>

pub fn settings(self, value: Settings) -> TestCaseConfigBuilder<SetSettings<S>>

where S::Settings: IsUnset,

Optional (Some / Option setters). The Settings to modify. If not provided, will use Settings::clone_current().

pub fn maybe_settings( self, value: Option<Settings>, ) -> TestCaseConfigBuilder<SetSettings<S>>

where S::Settings: IsUnset,

Optional (Some / Option setters). The Settings to modify. If not provided, will use Settings::clone_current().

pub fn description( self, value: impl Into<String>, ) -> TestCaseConfigBuilder<SetDescription<S>>

where S::Description: IsUnset,

Optional (Some / Option setters). The description of the test case. If not provided, will be extracted from the name of the current thread, which is based on the test case name.

This is particularly useful when using insta together with rstest. See: https://insta.rs/docs/patterns/

Examples

TestCase description for rstest cases

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use rstest::{fixture, rstest};
    use roadster::testing::snapshot::TestCase;

    #[fixture]
    fn case() -> TestCase {
        Default::default()
    }

    #[rstest]
    #[case(0)] // _case.description == case_1
    #[case::foo(0)] // _case.description == foo
    fn test(_case: TestCase, #[case] num: u32) {
        // Snapshot file name will have suffix of `@{_case.description}`, e.g. `@case_1`
        assert_snapshot!(num);
    }
}

TestCase with manually set description

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use roadster::testing::snapshot::{TestCase, TestCaseConfig};

    #[test]
    fn test() {
        let _case = TestCaseConfig::builder().description("Custom description").build();
        // Snapshot file name will have suffix of `@Custom description`
        assert_snapshot!("snapshot_value");
    }
}

pub fn maybe_description( self, value: Option<impl Into<String>>, ) -> TestCaseConfigBuilder<SetDescription<S>>

where S::Description: IsUnset,

Optional (Some / Option setters). The description of the test case. If not provided, will be extracted from the name of the current thread, which is based on the test case name.

This is particularly useful when using insta together with rstest. See: https://insta.rs/docs/patterns/

Examples

TestCase description for rstest cases

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use rstest::{fixture, rstest};
    use roadster::testing::snapshot::TestCase;

    #[fixture]
    fn case() -> TestCase {
        Default::default()
    }

    #[rstest]
    #[case(0)] // _case.description == case_1
    #[case::foo(0)] // _case.description == foo
    fn test(_case: TestCase, #[case] num: u32) {
        // Snapshot file name will have suffix of `@{_case.description}`, e.g. `@case_1`
        assert_snapshot!(num);
    }
}

TestCase with manually set description

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use roadster::testing::snapshot::{TestCase, TestCaseConfig};

    #[test]
    fn test() {
        let _case = TestCaseConfig::builder().description("Custom description").build();
        // Snapshot file name will have suffix of `@Custom description`
        assert_snapshot!("snapshot_value");
    }
}

pub fn set_suffix(self, value: bool) -> TestCaseConfigBuilder<SetSetSuffix<S>>

where S::SetSuffix: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to set the description as the suffix of the snapshot file.

It is particularly useful to set this to true when using insta together with rstest. See: https://insta.rs/docs/patterns/

pub fn maybe_set_suffix( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetSetSuffix<S>>

where S::SetSuffix: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to set the description as the suffix of the snapshot file.

It is particularly useful to set this to true when using insta together with rstest. See: https://insta.rs/docs/patterns/

pub fn redact_uuid(self, value: bool) -> TestCaseConfigBuilder<SetRedactUuid<S>>

where S::RedactUuid: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact UUIDs from snapshots. This is useful for tests involving dynamically created UUIDs that will be different on every test run, or involve real UUIDs that you don’t want leaked in your source code.

pub fn maybe_redact_uuid( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetRedactUuid<S>>

where S::RedactUuid: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact UUIDs from snapshots. This is useful for tests involving dynamically created UUIDs that will be different on every test run, or involve real UUIDs that you don’t want leaked in your source code.

pub fn redact_auth_tokens( self, value: bool, ) -> TestCaseConfigBuilder<SetRedactAuthTokens<S>>

where S::RedactAuthTokens: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact auth tokens from snapshots. This is useful for tests involving dynamically created auth tokens that will be different on every test run, or involve real auth tokens that you don’t want leaked in your source code.

pub fn maybe_redact_auth_tokens( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetRedactAuthTokens<S>>

where S::RedactAuthTokens: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact auth tokens from snapshots. This is useful for tests involving dynamically created auth tokens that will be different on every test run, or involve real auth tokens that you don’t want leaked in your source code.

pub fn redact_postgres_uri( self, value: bool, ) -> TestCaseConfigBuilder<SetRedactPostgresUri<S>>

where S::RedactPostgresUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact Postgres URIs from snapshots. This is useful for tests involving dynamically created Postgres instances that will be different on every test run, or involve real Postgres instances that you don’t want leaked in your source code.

pub fn maybe_redact_postgres_uri( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetRedactPostgresUri<S>>

where S::RedactPostgresUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact Postgres URIs from snapshots. This is useful for tests involving dynamically created Postgres instances that will be different on every test run, or involve real Postgres instances that you don’t want leaked in your source code.

pub fn redact_mysql_uri( self, value: bool, ) -> TestCaseConfigBuilder<SetRedactMysqlUri<S>>

where S::RedactMysqlUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact Mysql URIs from snapshots. This is useful for tests involving dynamically created Mysql instances that will be different on every test run, or involve real Mysql instances that you don’t want leaked in your source code.

pub fn maybe_redact_mysql_uri( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetRedactMysqlUri<S>>

where S::RedactMysqlUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact Mysql URIs from snapshots. This is useful for tests involving dynamically created Mysql instances that will be different on every test run, or involve real Mysql instances that you don’t want leaked in your source code.

pub fn redact_redis_uri( self, value: bool, ) -> TestCaseConfigBuilder<SetRedactRedisUri<S>>

where S::RedactRedisUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact Redis URIs from snapshots. This is useful for tests involving dynamically created Redis instances that will be different on every test run, or involve real Redis instances that you don’t want leaked in your source code.

pub fn maybe_redact_redis_uri( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetRedactRedisUri<S>>

where S::RedactRedisUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact Redis URIs from snapshots. This is useful for tests involving dynamically created Redis instances that will be different on every test run, or involve real Redis instances that you don’t want leaked in your source code.

pub fn redact_smtp_uri( self, value: bool, ) -> TestCaseConfigBuilder<SetRedactSmtpUri<S>>

where S::RedactSmtpUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact SMTP URIs from snapshots. This is useful for tests involving dynamically created SMTP instances that will be different on every test run, or involve real SMTP instances that you don’t want leaked in your source code.

pub fn maybe_redact_smtp_uri( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetRedactSmtpUri<S>>

where S::RedactSmtpUri: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact SMTP URIs from snapshots. This is useful for tests involving dynamically created SMTP instances that will be different on every test run, or involve real SMTP instances that you don’t want leaked in your source code.

pub fn redact_timestamp( self, value: bool, ) -> TestCaseConfigBuilder<SetRedactTimestamp<S>>

where S::RedactTimestamp: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact timestamps. This is useful for tests involving dynamically created timestamps that will be different on every test run.

pub fn maybe_redact_timestamp( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetRedactTimestamp<S>>

where S::RedactTimestamp: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to redact timestamps. This is useful for tests involving dynamically created timestamps that will be different on every test run.

pub fn bind_scope(self, value: bool) -> TestCaseConfigBuilder<SetBindScope<S>>

where S::BindScope: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to automatically bind the Settings to the current scope. If true, the settings will be automatically applied for the test in which the TestCase was built. If false, the settings will only be applied after manually calling Settings::bind_to_scope, or placing all relevant snapshot assertions inside a Settings::bind call.

Examples

Auto bind to scope

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use roadster::testing::snapshot::{TestCase, TestCaseConfig};

    #[test]
    fn test() {
        let _case = TestCaseConfig::builder().description("Custom description").build();
        // Snapshot file name will have suffix of `@Custom description`
        assert_snapshot!("snapshot_value");
    }
}

Manually bind Settings scope

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use roadster::testing::snapshot::{TestCase, TestCaseConfig};

    #[test]
    fn test() {
        let case = TestCaseConfig::builder().bind_scope(false).build();
        // This snapshot will not have a suffix
        assert_snapshot!("snapshot_value");

        case.settings.bind(|| {
            // This snapshot will have suffix `@test` (extracted from the curren thread name)
            assert_snapshot!("snapshot_value_2");
        });
    }
}

pub fn maybe_bind_scope( self, value: Option<bool>, ) -> TestCaseConfigBuilder<SetBindScope<S>>

where S::BindScope: IsUnset,

Optional (Some / Option setters). Default: true.

Whether to automatically bind the Settings to the current scope. If true, the settings will be automatically applied for the test in which the TestCase was built. If false, the settings will only be applied after manually calling Settings::bind_to_scope, or placing all relevant snapshot assertions inside a Settings::bind call.

Examples

Auto bind to scope

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use roadster::testing::snapshot::{TestCase, TestCaseConfig};

    #[test]
    fn test() {
        let _case = TestCaseConfig::builder().description("Custom description").build();
        // Snapshot file name will have suffix of `@Custom description`
        assert_snapshot!("snapshot_value");
    }
}

Manually bind Settings scope

#[cfg(test)]
mod tests {
    use insta::assert_snapshot;
    use roadster::testing::snapshot::{TestCase, TestCaseConfig};

    #[test]
    fn test() {
        let case = TestCaseConfig::builder().bind_scope(false).build();
        // This snapshot will not have a suffix
        assert_snapshot!("snapshot_value");

        case.settings.bind(|| {
            // This snapshot will have suffix `@test` (extracted from the curren thread name)
            assert_snapshot!("snapshot_value_2");
        });
    }
}

impl<S: IsComplete> TestCaseConfigBuilder<S>

pub fn build(self) -> TestCase