Struct EnvVarProvider 

pub struct EnvVarProvider { /* private fields */ }

Environment Variables Provider

This provider resolves feature flags from environment variables. The provider supports the following types:

• Int
• Float
• String
• Bool
• Struct (not supported)

The provider will return [EvaluationResult::Err(EvaluationError)] if the flag is not found or if the value is not of the expected type.

Trait Implementations

impl Debug for EnvVarProvider

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

Formats the value using the given formatter.

impl Default for EnvVarProvider

Default implementation for the Environment Variables Provider

fn default() -> Self

Returns the “default value” for a type.

impl FeatureProvider for EnvVarProvider

Implementation of the FeatureProvider trait for the Environment Variables Provider

fn metadata(&self) -> &ProviderMetadata

Returns the provider metadata

Example

#[tokio::test]
async fn test_metadata() {
   let provider = EnvVarProvider::default();
  assert_eq!(provider.metadata().name, "Environment Variables Provider");
}

fn resolve_bool_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, flag_key: &'life1 str, evaluation_context: &'life2 EvaluationContext, ) -> Pin<Box<dyn Future<Output = EvaluationResult<ResolutionDetails<bool>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

A logical true or false, as represented idiomatically in the implementation languages.

Example

#[tokio::test]
async fn test_resolve_string_value() {
    let provider = EnvVarProvider::default();
    let flag_key = "TEST_ENV_VAR";
    let value = "false";
    std::env::set_var(flag_key, value);

    let res = provider
        .resolve_string_value(flag_key, &EvaluationContext::default())
        .await;
    assert!(res.is_ok());
    assert_eq!(res.unwrap().value, value);
}

fn resolve_int_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, flag_key: &'life1 str, evaluation_context: &'life2 EvaluationContext, ) -> Pin<Box<dyn Future<Output = EvaluationResult<ResolutionDetails<i64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The 64-bit signed integer type.

Example

#[tokio::test]
async fn test_resolve_int_value() {
    let flag_key = "TEST_INT_ENV_VAR";
    let flag_value = i64::MAX.to_string();
    let provider = EnvVarProvider::default();
    std::env::set_var(flag_key, &flag_value);
    let result = provider.resolve_int_value(flag_key, &EvaluationContext::default()).await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap().value, flag_value.parse::<i64>().unwrap());
}

fn resolve_float_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, flag_key: &'life1 str, evaluation_context: &'life2 EvaluationContext, ) -> Pin<Box<dyn Future<Output = EvaluationResult<ResolutionDetails<f64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

A 64-bit floating point type

Example

#[tokio::test]
async fn test_resolve_float_value() {
    let flag_key = "TEST_FLOAT_ENV_VAR";
    let flag_value = std::f64::consts::PI.to_string();
    let provider = EnvVarProvider::default();

    std::env::set_var(flag_key, &flag_value);

    let result = provider
        .resolve_float_value(flag_key, &EvaluationContext::default())
        .await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap().value, flag_value.parse::<f64>().unwrap());
}

fn resolve_string_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, flag_key: &'life1 str, evaluation_context: &'life2 EvaluationContext, ) -> Pin<Box<dyn Future<Output = EvaluationResult<ResolutionDetails<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

A UTF-8 encoded string.

Example

#[tokio::test]
async fn test_resolve_string_value() {
    let provider = EnvVarProvider::default();
    let flag_key = "TEST_ENV_VAR";
    let value = "flag_value";
    std::env::set_var(flag_key, value);

    let res = provider
        .resolve_string_value(flag_key, &EvaluationContext::default())
        .await;
    assert!(res.is_ok());
    assert_eq!(res.unwrap().value, value);
}

fn resolve_struct_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _flag_key: &'life1 str, _evaluation_context: &'life2 EvaluationContext, ) -> Pin<Box<dyn Future<Output = EvaluationResult<ResolutionDetails<StructValue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Structured data, presented however is idiomatic in the implementation language, such as JSON or YAML.

fn initialize<'life0, 'life1, 'async_trait>( &'life0 mut self, context: &'life1 EvaluationContext, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

The provider MAY define an initialize function which accepts the global evaluation context as an argument and performs initialization logic relevant to the provider.

fn status(&self) -> ProviderStatus

The provider MAY define a status field/accessor which indicates the readiness of the provider, with possible values NOT_READY, READY, or ERROR.

fn hooks(&self) -> &[HookWrapper]

The provider MAY define a hooks field or accessor which returns a list of hooks that the provider supports.