feat(agent): allow to use an existing project for impact / explain / unit ids / test examples

Author: joelwurtz

src/api/explain_request.rs

@@ -3,8 +3,10 @@ use crate::{
     http::{Header, Request},
     router::{Router, RouterConfig, Trace},
 };
+use std::sync::Arc;
 
 use super::{Example, Rule};
+use crate::api::rules_message::RuleChangeSet;
 use serde::{Deserialize, Serialize};
 
 // Input
@@ -23,6 +25,12 @@ pub struct TmpRules {
     pub rules: Vec<Rule>,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct ExplainRequestProjectInput {
+    pub example: Example,
+    pub change_set: RuleChangeSet,
+}
+
 // Output
 
 #[derive(Serialize, Debug, Clone)]
@@ -50,17 +58,30 @@ pub struct ExplainRequestOutputError {
 // Implementation
 
 impl ExplainRequestOutput {
-    pub fn create_result(explain_request_input: ExplainRequestInput) -> Result<ExplainRequestOutput, ExplainRequestOutputError> {
+    pub fn create_result_from_project(
+        explain_request_input: ExplainRequestProjectInput,
+        existing_router: Arc<Router<Rule>>,
+    ) -> Result<ExplainRequestOutput, ExplainRequestOutputError> {
+        let explain_request_router = explain_request_input.change_set.update_existing_router(existing_router.clone());
+
+        Self::create_result(&explain_request_router, &explain_request_input.example)
+    }
+
+    pub fn create_result_without_project(
+        explain_request_input: ExplainRequestInput,
+    ) -> Result<ExplainRequestOutput, ExplainRequestOutputError> {
         let router_config = explain_request_input.router_config;
         let mut router = Router::<Rule>::from_config(router_config.clone());
 
         for rule in explain_request_input.rules.rules.iter() {
-            router.insert(rule.clone().into_route(&router_config));
+            router.insert(rule.clone());
         }
 
-        let example = &explain_request_input.example;
+        Self::create_result(&router, &explain_request_input.example)
+    }
 
-        let request = match Request::from_example(&router_config, example) {
+    fn create_result(router: &Router<Rule>, example: &Example) -> Result<ExplainRequestOutput, ExplainRequestOutputError> {
+        let request = match Request::from_example(&router.config, example) {
             Ok(request) => request,
             Err(e) => {
                 return Err(ExplainRequestOutputError {

src/api/impact.rs

@@ -1,9 +1,11 @@
 use crate::action::{Action, UnitTrace};
+use crate::api::rules_message::RuleChangeSet;
 use crate::api::{Example, Rule};
 use crate::http::Header;
 use crate::http::Request;
 use crate::router::{Router, RouterConfig, Trace};
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 use url::Url;
 
 const REDIRECTION_CODES: [u16; 4] = [301, 302, 307, 308];
@@ -20,6 +22,15 @@ pub struct ImpactInput {
     pub rules: TmpRules,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct ImpactProjectInput {
+    pub max_hops: u8,
+    pub with_redirection_loop: bool,
+    pub rule: Rule,
+    pub action: String,
+    pub change_set: RuleChangeSet,
+}
+
 // FIXME: find a way to avoid creating this structure.
 // It would be more convenient to inline the structure
 #[derive(Deserialize, Debug, Clone)]
@@ -92,6 +103,28 @@ impl Impact {
 }
 
 impl ImpactOutput {
+    pub fn from_impact_project(impact_input: ImpactProjectInput, existing_router: Arc<Router<Rule>>) -> ImpactOutput {
+        let mut impact_router = impact_input.change_set.update_existing_router(existing_router.clone());
+        let mut trace_unique_router = Router::<Rule>::from_arc_config(existing_router.config.clone());
+
+        impact_router.remove(impact_input.rule.id.as_str());
+
+        if impact_input.action == "add" || impact_input.action == "update" {
+            impact_router.insert(impact_input.rule.clone());
+            trace_unique_router.insert(impact_input.rule.clone());
+        }
+
+        let impacts = ImpactOutput::compute_impacts(
+            &impact_router,
+            &trace_unique_router,
+            impact_input.rule.examples,
+            impact_input.with_redirection_loop,
+            impact_input.max_hops,
+        );
+
+        ImpactOutput { impacts }
+    }
+
     pub fn create_result(impact_input: ImpactInput) -> ImpactOutput {
         let mut router = Router::<Rule>::from_config(impact_input.router_config.clone());
         let mut trace_unique_router = Router::<Rule>::from_config(impact_input.router_config.clone());
@@ -104,23 +137,40 @@ impl ImpactOutput {
             if rule.id == impact_input.rule.id {
                 continue;
             }
-            router.insert(rule.clone().into_route(&impact_input.router_config));
+            router.insert(rule.clone());
         }
 
         if impact_input.action == "add" || impact_input.action == "update" {
-            router.insert(impact_input.rule.clone().into_route(&impact_input.router_config));
-            trace_unique_router.insert(impact_input.rule.clone().into_route(&impact_input.router_config));
+            router.insert(impact_input.rule.clone());
+            trace_unique_router.insert(impact_input.rule.clone());
         }
 
-        let impacts = ImpactOutput::compute_impacts(&router, &trace_unique_router, &impact_input);
+        let impacts = ImpactOutput::compute_impacts(
+            &router,
+            &trace_unique_router,
+            impact_input.rule.examples,
+            impact_input.with_redirection_loop,
+            impact_input.max_hops,
+        );
 
         ImpactOutput { impacts }
     }
 
-    fn compute_impacts(router: &Router<Rule>, trace_unique_router: &Router<Rule>, impact_input: &ImpactInput) -> Vec<Impact> {
+    fn compute_impacts(
+        router: &Router<Rule>,
+        trace_unique_router: &Router<Rule>,
+        examples: Option<Vec<Example>>,
+        with_redirection_loop: bool,
+        max_hops: u8,
+    ) -> Vec<Impact> {
         let mut impacts = Vec::new();
-        for example in impact_input.rule.examples.as_ref().unwrap().iter() {
-            let request = match Request::from_example(&router.config, example) {
+
+        if examples.is_none() {
+            return impacts;
+        }
+
+        for example in examples.unwrap() {
+            let request = match Request::from_example(&router.config, &example) {
                 Ok(request) => request,
                 Err(e) => {
                     impacts.push(Impact::new_with_error(
@@ -163,8 +213,8 @@ impl ImpactOutput {
 
             unit_trace.squash_with_target_unit_traces();
 
-            let redirection_loop = if impact_input.with_redirection_loop {
-                Some(ImpactOutput::compute_redirection_loop(router, impact_input, example))
+            let redirection_loop = if with_redirection_loop {
+                Some(ImpactOutput::compute_redirection_loop(router, max_hops, &example))
             } else {
                 None
             };
@@ -187,7 +237,7 @@ impl ImpactOutput {
         impacts
     }
 
-    fn compute_redirection_loop(router: &Router<Rule>, impact_input: &ImpactInput, example: &Example) -> RedirectionLoop {
+    fn compute_redirection_loop(router: &Router<Rule>, max_hops: u8, example: &Example) -> RedirectionLoop {
         let mut current_url = example.url.clone();
         let mut current_method = example.method.clone().unwrap_or(String::from("GET"));
         let mut error = None;
@@ -198,7 +248,7 @@ impl ImpactOutput {
             method: current_method.clone(),
         }];
 
-        'outer: for i in 1..=impact_input.max_hops {
+        'outer: for i in 1..=max_hops {
             let new_example = example.with_url(current_url.clone()).with_method(Some(current_method.clone()));
 
             let request = Request::from_example(&router.config, &new_example).unwrap();
@@ -260,7 +310,7 @@ impl ImpactOutput {
                 method: current_method.clone(),
             });
 
-            if i >= impact_input.max_hops {
+            if i >= max_hops {
                 error = Some(RedirectionError::TooManyHops);
                 break;
             }

src/api/mod.rs

@@ -29,11 +29,11 @@ pub use body_filter::{BodyFilter, HTMLBodyFilter, TextAction, TextBodyFilter};
 pub use date_time::DateTimeConstraint;
 pub use examples::Example;
 #[cfg(feature = "router")]
-pub use explain_request::{ExplainRequestInput, ExplainRequestOutput, ExplainRequestOutputError};
+pub use explain_request::{ExplainRequestInput, ExplainRequestOutput, ExplainRequestOutputError, ExplainRequestProjectInput};
 pub use header::Header;
 pub use header_filter::HeaderFilter;
 #[cfg(feature = "router")]
-pub use impact::{ImpactInput, ImpactOutput};
+pub use impact::{ImpactInput, ImpactOutput, ImpactProjectInput};
 pub use ip::IpConstraint;
 pub use marker::Marker;
 #[cfg(feature = "router")]
@@ -42,8 +42,8 @@ pub use rule::Rule;
 pub use rules_message::RulesMessage;
 pub use source::Source;
 #[cfg(feature = "router")]
-pub use test_examples::{TestExamplesInput, TestExamplesOutput};
+pub use test_examples::{TestExamplesInput, TestExamplesOutput, TestExamplesProjectInput};
 pub use transformer::Transformer;
 #[cfg(feature = "router")]
-pub use unit_ids::{UnitIdsInput, UnitIdsOutput};
+pub use unit_ids::{UnitIdsInput, UnitIdsOutput, UnitIdsProjectInput};
 pub use variable::{Variable, VariableKind};

src/api/rule.rs

@@ -1,7 +1,7 @@
 use crate::api::{BodyFilter, DateTimeConstraint, Example, HeaderFilter, IpConstraint, Marker, Source, Variable};
 use crate::http::Request;
 use crate::marker::{Marker as RouteMarker, MarkerString, StaticOrDynamic, Transform};
-use crate::router::{Route, RouteDateTime, RouteHeader, RouteHeaderKind, RouteIp, RouteTime, RouteWeekday, RouterConfig};
+use crate::router::{IntoRoute, Route, RouteDateTime, RouteHeader, RouteHeaderKind, RouteIp, RouteTime, RouteWeekday, RouterConfig};
 use cidr::AnyIpCidr;
 use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
 use serde::{Deserialize, Serialize};
@@ -277,8 +277,10 @@ impl Rule {
 
         headers
     }
+}
 
-    pub fn into_route(self, config: &RouterConfig) -> Route<Rule> {
+impl IntoRoute<Rule> for Rule {
+    fn into_route(self, config: &RouterConfig) -> Route<Rule> {
         Route::new(
             self.source.methods.clone(),
             self.source.exclude_methods,

src/api/rules_message.rs

@@ -1,8 +1,27 @@
 use crate::api::Rule;
+use crate::router::Router;
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct RulesMessage {
     #[serde(rename = "hydra:member")]
     pub rules: Vec<Rule>,
 }
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct RuleChangeSet {
+    pub deleted: Vec<String>,
+    pub added: Vec<Rule>,
+    pub updated: Vec<Rule>,
+}
+
+impl RuleChangeSet {
+    pub fn update_existing_router(self, existing_router: Arc<Router<Rule>>) -> Router<Rule> {
+        let mut new_router = existing_router.as_ref().clone();
+
+        new_router.apply_change_set(self.added, self.updated, self.deleted);
+
+        new_router
+    }
+}

src/api/test_examples.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::sync::Arc;
 
 use crate::{
     action::{Action, UnitTrace},
@@ -7,6 +8,7 @@ use crate::{
 };
 
 use super::{Example, Rule};
+use crate::api::rules_message::RuleChangeSet;
 use linked_hash_set::LinkedHashSet;
 use serde::{Deserialize, Serialize};
 
@@ -18,6 +20,11 @@ pub struct TestExamplesInput {
     pub rules: TmpRules,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct TestExamplesProjectInput {
+    pub change_set: RuleChangeSet,
+}
+
 // FIXME: find a way to avoid creating this structure.
 // It would be more convenient to inline the structure
 #[derive(Deserialize, Debug, Clone)]
@@ -65,11 +72,92 @@ pub struct ErroredExample {
 // Implementation
 
 impl TestExamplesOutput {
+    pub fn from_project(test_examples_input: TestExamplesProjectInput, existing_router: Arc<Router<Rule>>) -> TestExamplesOutput {
+        let test_example_router = test_examples_input.change_set.update_existing_router(existing_router.clone());
+        let mut results = TestExamplesOutput::default();
+
+        for (id, route) in test_example_router.routes() {
+            let examples = &route.handler().examples;
+
+            if examples.is_none() {
+                continue;
+            }
+
+            for example in examples.as_ref().unwrap().iter() {
+                if example.unit_ids_applied.is_none() {
+                    continue;
+                }
+
+                let request = match Request::from_example(&test_example_router.config, example) {
+                    Ok(request) => request,
+                    Err(e) => {
+                        results.add_errored_example(route.handler(), example.clone(), e.to_string());
+                        continue;
+                    }
+                };
+                let mut unit_trace = UnitTrace::default();
+
+                let routes = test_example_router.match_request(&request);
+                let mut action = Action::from_routes_rule(routes, &request, Some(&mut unit_trace));
+
+                let action_status_code = action.get_status_code(0, Some(&mut unit_trace));
+                let (final_status_code, backend_status_code) = if action_status_code != 0 {
+                    (action_status_code, action_status_code)
+                } else {
+                    // We call the backend and get a response code
+                    let backend_status_code = example.response_status_code.unwrap_or(200);
+                    let final_status_code = action.get_status_code(backend_status_code, Some(&mut unit_trace));
+                    (final_status_code, backend_status_code)
+                };
+
+                action.filter_headers(Vec::new(), backend_status_code, false, Some(&mut unit_trace));
+
+                if let Some(mut body_filter) = action.create_filter_body(backend_status_code, &[]) {
+                    let body = "<!DOCTYPE html>
+<html>
+    <head>
+    </head>
+    <body>
+    </body>
+</html>";
+
+                    body_filter.filter(body.into(), Some(&mut unit_trace));
+                    body_filter.end(Some(&mut unit_trace));
+                }
+
+                action.should_log_request(true, final_status_code, Some(&mut unit_trace));
+
+                unit_trace.squash_with_target_unit_traces();
+
+                let unit_ids_not_applied_anymore = unit_trace.diff(example.unit_ids_applied.clone().unwrap());
+
+                // If it should match but not unit are applied anymore
+                // If it should match but the rule is not applied
+                // If it should not matche but the rule is applied
+                if example.must_match && (!unit_ids_not_applied_anymore.is_empty() || !unit_trace.rule_ids_contains(id.as_str()))
+                    || !example.must_match && unit_trace.rule_ids_contains(id.as_str())
+                {
+                    results.add_failed_example(
+                        route.handler(),
+                        example.clone(),
+                        unit_trace.get_rule_ids_applied(),
+                        unit_trace.get_unit_ids_applied(),
+                        unit_ids_not_applied_anymore,
+                    );
+                }
+
+                results.increment_example_count();
+            }
+        }
+
+        results
+    }
+
     pub fn create_result(test_examples_input: TestExamplesInput) -> TestExamplesOutput {
         let mut router = Router::<Rule>::from_config(test_examples_input.router_config.clone());
 
         for rule in test_examples_input.rules.rules.iter() {
-            router.insert(rule.clone().into_route(&test_examples_input.router_config));
+            router.insert(rule.clone());
         }
 
         router.cache(10000);