fluxpro-engine 0.1.10

A feature-gated workflow and process engine
Documentation
#![cfg(feature = "editor")]
#![cfg(all(feature = "admin", feature = "runtime", not(target_arch = "wasm32")))]
use fluxpro_engine::editor::*;
use fluxpro_engine::{
    admin::{FluxproAdminService, PageRequest, ProcessInstanceFilter},
    db_service::FluxproDbServiceImpl,
    models::{
        commands::start_process_instance::StartProcessInstance,
        context_map::context_map::ContextMap, id_field::IdField,
    },
    service::process_service::{FluxproService, FluxproServiceImpl},
};
use sqlx::PgPool;
use std::sync::Arc;

#[sqlx::test(migrations = false)]
#[ignore = "requires a temporary PostgreSQL DATABASE_URL"]
async fn monitor_queries_and_publication_preserve_version_boundaries(pool: PgPool) {
    fluxpro_engine::migrations::migrate(&pool).await.unwrap();
    let service = FluxproServiceImpl::new(Arc::new(FluxproDbServiceImpl::new(pool.clone())));
    let admin = FluxproAdminService::new(pool.clone());
    let doc = EditorDocument::default()
        .prepare_publication(None, "1.0.0")
        .unwrap();
    service
        .publish_process_def_from_source(&doc.definition, &doc.to_project_yaml().unwrap(), None)
        .await
        .unwrap();
    for number in 0..3 {
        service
            .start_process_instance(
                doc.definition.key.clone(),
                StartProcessInstance {
                    process_id: IdField::new(format!("ORDER_{number}")).unwrap(),
                    version: None,
                    context: ContextMap::default(),
                },
            )
            .await
            .unwrap();
    }
    let source = admin
        .get_current_process_definition_by_key(doc.definition.key.get_id())
        .await
        .unwrap();
    let doc = fluxpro_engine::editor::admin::monitor_document(source).unwrap();
    let page = admin
        .list_process_instances(ProcessInstanceFilter::default(), PageRequest::default())
        .await
        .unwrap();
    let instance = &page.items[0];
    sqlx::query("update fluxpro.process_instance set current_node_ref=(select uuid from fluxpro.process_def_node where process_def_uuid=$1 and node_id='start') where uuid=$2")
        .bind(instance.process_definition_uuid).bind(instance.uuid).execute(&pool).await.unwrap();
    sqlx::query("insert into fluxpro.process_instance_log(process_instance_uuid,level,event_type,source,message) select $1,'info','test','integration','event '||n from generate_series(1,280) n")
        .bind(instance.uuid).execute(&pool).await.unwrap();
    sqlx::query("insert into fluxpro.signal_history(process_id,signal_name,payload) select $1,'test',jsonb_build_object('n',n) from generate_series(1,280) n")
        .bind(&instance.token).execute(&pool).await.unwrap();
    sqlx::query("insert into fluxpro.process_incident(process_instance_uuid,task_uuid,task,kind,reason,attempt) values ($1,gen_random_uuid(),'{}','test','unresolved test incident',1)")
        .bind(instance.uuid).execute(&pool).await.unwrap();
    let mut request = MonitorRequest {
        scope: MonitorScope::from_document(&doc),
        revision: 5,
        active_counts_only: false,
        query: MonitorQuery {
            search: instance.uuid.to_string(),
            node_id: Some("start".into()),
            limit: 1,
            ..Default::default()
        },
        instances: vec![MonitorInstanceRequest {
            uuid: instance.uuid.to_string(),
            log_limit: 350,
            signal_limit: 350,
        }],
    };
    let snapshot =
        fluxpro_engine::editor::admin::load_monitor_snapshot(&admin, request.clone()).await;
    assert!(snapshot.error.is_none(), "{:?}", snapshot.error);
    assert_eq!(snapshot.request, request);
    assert_eq!(snapshot.instances.total, 1);
    assert_eq!(snapshot.instances.items.len(), 1);
    assert_eq!(
        snapshot
            .node_counts
            .iter()
            .map(|c| c.instance_count)
            .sum::<u64>(),
        1
    );
    assert_eq!(
        snapshot.details[0].logs.items.len() as u64,
        snapshot.details[0].logs.total
    );
    assert!(snapshot.details[0].logs.items.len() >= 280);
    assert_eq!(snapshot.details[0].signals.items.len(), 280);
    assert_eq!(snapshot.details[0].signals.total, 280);
    assert_eq!(
        snapshot.node_counts.iter().map(|c| c.errors).sum::<u64>(),
        1
    );
    assert_eq!(
        snapshot.details[0].instance.issues[0].message,
        "unresolved test incident"
    );
    request.query.node_id = Some("finish".into());
    let empty = fluxpro_engine::editor::admin::load_monitor_snapshot(&admin, request.clone()).await;
    assert_eq!(empty.instances.total, 0);
    assert_eq!(empty.node_counts, snapshot.node_counts);
    let mut changed = doc.clone();
    changed
        .positions
        .insert("start".into(), Position::new(444., 222.));
    changed.definition.name = "Updated definition".into();
    let published = changed.prepare_publication(Some(&doc), "1.0.1").unwrap();
    service
        .publish_process_def_from_source(
            &published.definition,
            &published.to_project_yaml().unwrap(),
            doc.definition.uuid,
        )
        .await
        .unwrap();
    assert!(
        service
            .create_process_def(&published.definition)
            .await
            .is_err(),
        "duplicate versions must fail"
    );
    let current = service
        .get_process(doc.definition.key.clone(), None)
        .await
        .unwrap();
    assert_eq!(current.version.as_str(), "1.0.1");
    assert_eq!(
        admin
            .get_process_instance(instance.uuid)
            .await
            .unwrap()
            .summary
            .process_definition_uuid,
        doc.definition.uuid.unwrap()
    );
    let reopened = fluxpro_engine::editor::admin::monitor_document(
        admin
            .get_current_process_definition_by_key(doc.definition.key.get_id())
            .await
            .unwrap(),
    )
    .unwrap();
    assert_eq!(reopened.positions, published.positions);
    let newer = published.prepare_publication(Some(&doc), "1.0.2").unwrap();
    let newer_yaml = newer.to_project_yaml().unwrap();
    let (first, second) = tokio::join!(
        service.publish_process_def_from_source(
            &newer.definition,
            &newer_yaml,
            doc.definition.uuid
        ),
        service.publish_process_def_from_source(
            &newer.definition,
            &newer_yaml,
            doc.definition.uuid
        ),
    );
    assert_ne!(
        first.is_ok(),
        second.is_ok(),
        "exactly one concurrent publication should win"
    );
    assert!(
        service
            .publish_process_def_from_source(
                &published.definition,
                &published.to_project_yaml().unwrap(),
                doc.definition.uuid
            )
            .await
            .is_err()
    );
    assert!(
        service
            .publish_process_def_from_source(&newer.definition, &newer_yaml, None)
            .await
            .is_err(),
        "new process cannot reuse an existing key"
    );
    let restricted =
        fluxpro_engine::editor::admin::load_definition_snapshot(&admin, request.clone()).await;
    assert!(restricted.error.is_none());
    assert!(restricted.instances.items.is_empty());
    assert!(restricted.details.is_empty());
    request.scope = MonitorScope::from_document(&reopened);
    let foreign =
        fluxpro_engine::editor::admin::load_monitor_snapshot(&admin, request.clone()).await;
    assert!(foreign.error.is_some());
    assert!(foreign.details.is_empty());
    assert_eq!(foreign.request, request);
}

#[sqlx::test(migrations = false)]
#[ignore = "requires a temporary PostgreSQL DATABASE_URL"]
async fn active_node_counts_exclude_completed_but_keep_suspended(pool: PgPool) {
    fluxpro_engine::migrations::migrate(&pool).await.unwrap();
    let service = FluxproServiceImpl::new(Arc::new(FluxproDbServiceImpl::new(pool.clone())));
    let admin = FluxproAdminService::new(pool.clone());
    let document = EditorDocument::default()
        .prepare_publication(None, "1.0.0")
        .unwrap();
    service
        .create_process_def(&document.definition)
        .await
        .unwrap();
    let source = admin
        .get_current_process_definition_by_key("new_process")
        .await
        .unwrap();
    let definition_uuid = source.uuid;
    for (name, node, state) in [
        ("working", "start", "running"),
        ("done", "finish", "running"),
        ("incident", "finish", "suspended"),
    ] {
        sqlx::query("insert into fluxpro.process_instance(process_def_uuid,process_id,token,current_node_ref,execution_state) values ($1,$2,$2,(select uuid from fluxpro.process_def_node where process_def_uuid=$1 and node_id=$3),$4)")
            .bind(definition_uuid).bind(name).bind(node).bind(state).execute(&pool).await.unwrap();
    }
    let document = fluxpro_engine::editor::admin::monitor_document(source).unwrap();
    let document: EditorDocument =
        serde_json::from_value(serde_json::to_value(document).unwrap()).unwrap();
    let request = MonitorRequest {
        scope: MonitorScope::from_document(&document),
        active_counts_only: true,
        ..Default::default()
    };
    let snapshot =
        fluxpro_engine::editor::admin::load_monitor_snapshot(&admin, request.clone()).await;
    assert!(snapshot.error.is_none(), "{:?}", snapshot.error);
    assert_eq!(
        snapshot
            .node_counts
            .iter()
            .map(|c| c.instance_count)
            .sum::<u64>(),
        2
    );
    assert_eq!(
        snapshot
            .node_counts
            .iter()
            .find(|c| c.node_id == "finish")
            .unwrap()
            .instance_count,
        1
    );
    assert_eq!(
        snapshot.instances.total, 3,
        "list history is independently filterable"
    );
    let all = admin
        .get_process_node_instance_counts(definition_uuid)
        .await
        .unwrap();
    assert_eq!(all.iter().map(|c| c.instance_count).sum::<i64>(), 3);
    let mut filtered = request;
    filtered.query.node_id = Some("start".into());
    let filtered = fluxpro_engine::editor::admin::load_monitor_snapshot(&admin, filtered).await;
    assert_eq!(filtered.instances.total, 1);
    assert_eq!(filtered.node_counts, snapshot.node_counts);
}