Implement flag engine v0.1.0

.github/workflows/pull-request.yml

@@ -0,0 +1,30 @@
+name: Rust Flag Engine Pull Request
+
+on:
+    pull_request:
+        types: [opened, synchronize, reopened, ready_for_review]
+        branches:
+            - main
+            - release**
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Cloning repo
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+        submodules: recursive
+    - uses: actions/checkout@v2
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+    - name: Check Formatting
+      run: cargo fmt --all -- --check

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tests/engine_tests/engine-test-data"]
+	path = tests/engine_tests/engine-test-data
+	url = git@github.com:Flagsmith/engine-test-data.git

.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+repos:
+  - repo: https://github.com/doublify/pre-commit-rust
+    rev: v1.0
+    hooks:
+      - id: fmt
+      - id: cargo-check

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "flagsmith-flag-engine"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+chrono = { version = "0.4", features = ["serde"] }
+md-5="0.10.1"
+num-bigint = "0.4"
+num-traits = "0.2.14"
+uuid = { version = "0.8", features = ["serde", "v4"] }
+regex = "1"
+semver = "1.0"
+
+[dev-dependencies]
+rstest = "0.12.0"

README.md

@@ -1,2 +1,26 @@
-# flagsmith-rust-flag-engine
-Flag Engine implementaion in Rust
+[![Feature Flag, Remote Config and A/B Testing platform, Flagsmith](https://github.com/Flagsmith/flagsmith/raw/main/static-files/hero.png)](https://www.flagsmith.com/)
+
+[Flagsmith](https://www.flagsmith.com/) is an open source, fully featured, Feature Flag and Remote Config service. Use
+our hosted API, deploy to your own private cloud, or run on-premise.
+
+# Flagsmith Rust Flag Engine
+
+This project is the rust clone of flagsmith flag engine [Flagsmith API](https://github.com/Flagsmith/flagsmith-engine).
+
+## Contributing
+
+Please read [CONTRIBUTING.md](https://docs.flagsmith.com/platform/contributing) for details on our code of conduct, and the process for submitting pull requests
+
+## Getting Help
+
+If you encounter a bug or feature request we would like to hear about it. Before you submit an issue please search existing issues in order to prevent duplicates.
+
+## Get in touch
+
+If you have any questions about our projects you can email <a href="mailto:support@flagsmith.com">support@flagsmith.com</a>.
+
+## Useful links
+
+[Website](https://www.flagsmith.com/)
+
+[Documentation](https://docs.flagsmith.com/)

src/engine.rs

@@ -0,0 +1,207 @@
+use super::environments;
+use super::error;
+use super::features;
+use super::identities;
+use super::segments::evaluator;
+use crate::features::Feature;
+use crate::features::FeatureState;
+use std::collections::HashMap;
+
+//Returns a vector of feature states for a given environment
+pub fn get_environment_feature_states(
+    environment: environments::Environment,
+) -> Vec<features::FeatureState> {
+    if environment.project.hide_disabled_flags {
+        return environment
+            .feature_states
+            .iter()
+            .filter(|fs| fs.enabled)
+            .map(|fs| fs.clone())
+            .collect();
+    }
+    return environment.feature_states;
+}
+
+// Returns a specific feature state for a given feature_name in a given environment
+// If exists else returns a FeatureStateNotFound error
+pub fn get_environment_feature_state(
+    environment: environments::Environment,
+    feature_name: &str,
+) -> Result<features::FeatureState, error::Error> {
+    let fs = environment
+        .feature_states
+        .iter()
+        .filter(|fs| fs.feature.name == feature_name)
+        .next()
+        .ok_or(error::Error::new(error::ErrorKind::FeatureStateNotFound));
+    return Ok(fs?.clone());
+}
+
+// Returns a vector of feature state models based on the environment, any matching
+// segments and any specific identity overrides
+pub fn get_identity_feature_states(
+    environment: &environments::Environment,
+    identity: &identities::Identity,
+    override_traits: Option<&Vec<identities::Trait>>,
+) -> Vec<features::FeatureState> {
+    let feature_states =
+        get_identity_feature_states_map(environment, identity, override_traits).into_values();
+    if environment.project.hide_disabled_flags {
+        return feature_states.filter(|fs| fs.enabled).collect();
+    }
+    return feature_states.collect();
+}
+
+// Returns a specific feature state based on the environment, any matching
+// segments and any specific identity overrides
+// If exists else returns a FeatureStateNotFound error
+pub fn get_identity_feature_state(
+    environment: &environments::Environment,
+    identity: &identities::Identity,
+    feature_name: &str,
+    override_traits: Option<&Vec<identities::Trait>>,
+) -> Result<features::FeatureState, error::Error> {
+    let feature_states =
+        get_identity_feature_states_map(environment, identity, override_traits).into_values();
+    let fs = feature_states
+        .filter(|fs| fs.feature.name == feature_name)
+        .next()
+        .ok_or(error::Error::new(error::ErrorKind::FeatureStateNotFound));
+
+    return Ok(fs?.clone());
+}
+
+fn get_identity_feature_states_map(
+    environment: &environments::Environment,
+    identity: &identities::Identity,
+    override_traits: Option<&Vec<identities::Trait>>,
+) -> HashMap<Feature, FeatureState> {
+    let mut feature_states: HashMap<Feature, FeatureState> = HashMap::new();
+
+    // Get feature states from the environment
+    for fs in environment.feature_states.clone() {
+        feature_states.insert(fs.feature.clone(), fs);
+    }
+
+    // Override with any feature states defined by matching segments
+    let identity_segments =
+        evaluator::get_identity_segments(environment, identity, override_traits);
+    for matching_segments in identity_segments {
+        for feature_state in matching_segments.feature_states {
+            feature_states.insert(feature_state.feature.clone(), feature_state);
+        }
+    }
+    // Override with any feature states defined directly the identity
+    for feature_state in identity.identity_features.clone() {
+        feature_states.insert(feature_state.feature.clone(), feature_state);
+    }
+    return feature_states;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    static IDENTITY_JSON: &str = r#"{
+            "identifier": "test_user",
+            "environment_api_key": "test_api_key",
+            "created_date": "2022-03-02T12:31:05.309861",
+            "identity_features": [],
+            "identity_traits": [],
+            "identity_uuid":""
+        }"#;
+    static ENVIRONMENT_JSON: &str = r#"
+        {
+ "api_key": "test_key",
+ "project": {
+  "name": "Test project",
+  "organisation": {
+   "feature_analytics": false,
+   "name": "Test Org",
+   "id": 1,
+   "persist_trait_data": true,
+   "stop_serving_flags": false
+  },
+  "id": 1,
+  "hide_disabled_flags": true,
+  "segments": []
+ },
+ "segment_overrides": [],
+ "id": 1,
+ "feature_states": [
+  {
+   "multivariate_feature_state_values": [],
+   "feature_state_value": true,
+   "django_id": 1,
+   "feature": {
+    "name": "feature1",
+    "type": null,
+    "id": 1
+   },
+   "enabled": false
+  },
+  {
+   "multivariate_feature_state_values": [],
+   "feature_state_value": null,
+   "django_id": 2,
+   "feature": {
+    "name": "feature_2",
+    "type": null,
+    "id": 2
+   },
+   "enabled": true
+  }
+ ]
+}"#;
+
+    #[test]
+    fn get_environment_feature_states_only_return_enabled_fs_if_hide_disabled_flags_is_true() {
+        let environment: environments::Environment =
+            serde_json::from_str(ENVIRONMENT_JSON).unwrap();
+
+        let environment_feature_states = get_environment_feature_states(environment);
+        assert_eq!(environment_feature_states.len(), 1);
+        assert_eq!(environment_feature_states[0].django_id.unwrap(), 2);
+    }
+
+    #[test]
+    fn get_environment_feature_state_returns_correct_feature_state() {
+        let environment: environments::Environment =
+            serde_json::from_str(ENVIRONMENT_JSON).unwrap();
+        let feature_name = "feature_2";
+        let feature_state = get_environment_feature_state(environment, feature_name).unwrap();
+        assert_eq!(feature_state.feature.name, feature_name)
+    }
+
+    #[test]
+    fn get_environment_feature_state_returns_error_if_feature_state_does_not_exists() {
+        let environment: environments::Environment =
+            serde_json::from_str(ENVIRONMENT_JSON).unwrap();
+        let feature_name = "feature_that_does_not_exists";
+        let err = get_environment_feature_state(environment, feature_name)
+            .err()
+            .unwrap();
+        assert_eq!(err.kind, error::ErrorKind::FeatureStateNotFound)
+    }
+
+    #[test]
+    fn get_identity_feature_state_returns_correct_feature_state() {
+        let environment: environments::Environment =
+            serde_json::from_str(ENVIRONMENT_JSON).unwrap();
+        let feature_name = "feature_2";
+        let identity: identities::Identity = serde_json::from_str(IDENTITY_JSON).unwrap();
+        let feature_state =
+            get_identity_feature_state(&environment, &identity, feature_name, None).unwrap();
+        assert_eq!(feature_state.feature.name, feature_name)
+    }
+    #[test]
+    fn get_identity_feature_state_returns_error_if_feature_state_does_not_exists() {
+        let environment: environments::Environment =
+            serde_json::from_str(ENVIRONMENT_JSON).unwrap();
+        let feature_name = "feature_that_does_not_exists";
+        let identity: identities::Identity = serde_json::from_str(IDENTITY_JSON).unwrap();
+        let err = get_identity_feature_state(&environment, &identity, feature_name, None)
+            .err()
+            .unwrap();
+        assert_eq!(err.kind, error::ErrorKind::FeatureStateNotFound)
+    }
+}

src/environments/builders.rs

@@ -0,0 +1,35 @@
+use super::Environment;
+use super::EnvironmentAPIKey;
+
+pub fn build_environment_struct(value: serde_json::Value) -> Environment {
+    let environment: Environment = serde_json::from_value(value).unwrap();
+    return environment;
+}
+
+pub fn build_environment_api_key_struct(value: serde_json::Value) -> EnvironmentAPIKey {
+    let environment_api_key: EnvironmentAPIKey = serde_json::from_value(value).unwrap();
+    return environment_api_key;
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn build_environment_api_key_struct_returns_correct_struct() {
+        // Given
+        let key = "ser.test_key".to_string();
+        let api_key_json = serde_json::json!({
+            "key": key,
+            "active": true,
+            "created_at": "2022-03-02T12:31:05.309861+00:00",
+            "client_api_key": "client_key",
+            "id": 1,
+            "name": "api key 1",
+            "expires_at": null
+        });
+        // When
+        let api_key_struct = build_environment_api_key_struct(api_key_json);
+        // Then
+        assert_eq!(api_key_struct.key, key);
+    }
+}