temporalio 0.1.1 → 0.2.0

data/bridge/sdk-core/tests/integ_tests/queries_tests.rs

@@ -1,314 +0,0 @@
-use assert_matches::assert_matches;
-use futures::{prelude::stream::FuturesUnordered, FutureExt, StreamExt};
-use std::time::Duration;
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        workflow_activation::{workflow_activation_job, WorkflowActivationJob},
-        workflow_commands::{QueryResult, QuerySuccess, StartTimer},
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery},
-};
-use temporal_sdk_core_test_utils::{
-    drain_pollers_and_shutdown, init_core_and_create_wf, WorkerTestHelpers,
-};
-
-#[tokio::test]
-async fn simple_query_legacy() {
-    let query_resp = b"response";
-    let mut starter = init_core_and_create_wf("simple_query_legacy").await;
-    let core = starter.get_worker().await;
-    let workflow_id = starter.get_task_queue().to_string();
-    let task = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id.clone(),
-        vec![
-            StartTimer {
-                seq: 0,
-                start_to_fire_timeout: Some(prost_dur!(from_millis(500))),
-            }
-            .into(),
-            StartTimer {
-                seq: 1,
-                start_to_fire_timeout: Some(prost_dur!(from_secs(3))),
-            }
-            .into(),
-        ],
-    ))
-    .await
-    .unwrap();
-    tokio::time::sleep(Duration::from_secs(1)).await;
-    // Query after timer should have fired and there should be new WFT
-    let query_fut = async {
-        starter
-            .get_client()
-            .await
-            .query_workflow_execution(
-                workflow_id,
-                task.run_id.to_string(),
-                WorkflowQuery {
-                    query_type: "myquery".to_string(),
-                    query_args: Some(b"hi".into()),
-                    header: None,
-                },
-            )
-            .await
-            .unwrap()
-    };
-    let workflow_completions_future = async {
-        // Give query a beat to get going
-        tokio::time::sleep(Duration::from_millis(400)).await;
-        // This poll *should* have the `queries` field populated, but doesn't, seemingly due to
-        // a server bug. So, complete the WF task of the first timer firing with empty commands
-        let task = core.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-            }]
-        );
-        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            task.run_id,
-            vec![],
-        ))
-        .await
-        .unwrap();
-        let task = core.poll_workflow_activation().await.unwrap();
-        // Poll again, and we end up getting a `query` field query response
-        let query = assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-            }] => q
-        );
-        // Complete the query
-        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-            task.run_id,
-            QueryResult {
-                query_id: query.query_id.clone(),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some(query_resp.into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
-        ))
-        .await
-        .unwrap();
-        // Finish the workflow
-        let task = core.poll_workflow_activation().await.unwrap();
-        core.complete_execution(&task.run_id).await;
-    };
-    let (q_resp, _) = tokio::join!(query_fut, workflow_completions_future);
-    // Ensure query response is as expected
-    assert_eq!(&q_resp.unwrap()[0].data, query_resp);
-}
-
-#[rstest]
-#[case::no_eviction(false)]
-#[case::with_eviction(true)]
-#[tokio::test]
-async fn query_after_execution_complete(#[case] do_evict: bool) {
-    let query_resp = b"response";
-    let mut starter =
-        init_core_and_create_wf(&format!("query_after_execution_complete-{do_evict}")).await;
-    let core = &starter.get_worker().await;
-    let workflow_id = &starter.get_task_queue().to_string();
-
-    let do_workflow = |go_until_query: bool| async move {
-        loop {
-            let task = core.poll_workflow_activation().await.unwrap();
-
-            // When we see the query, handle it.
-            if go_until_query {
-                if let [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(query)),
-                }] = task.jobs.as_slice()
-                {
-                    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
-                        task.run_id,
-                        QueryResult {
-                            query_id: query.query_id.clone(),
-                            variant: Some(
-                                QuerySuccess {
-                                    response: Some(query_resp.into()),
-                                }
-                                .into(),
-                            ),
-                        }
-                        .into(),
-                    ))
-                    .await
-                    .unwrap();
-                    break "".to_string();
-                }
-            }
-
-            if matches!(
-                task.jobs.as_slice(),
-                [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
-                }]
-            ) {
-                core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-                    .await
-                    .unwrap();
-                continue;
-            }
-            if matches!(
-                task.jobs.as_slice(),
-                [WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
-                }]
-            ) {
-                core.complete_timer(&task.run_id, 1, Duration::from_millis(500))
-                    .await;
-            } else {
-                core.complete_execution(&task.run_id).await;
-            }
-            if !go_until_query {
-                break task.run_id;
-            }
-        }
-    };
-
-    let run_id = &do_workflow(false).await;
-    assert!(!run_id.is_empty());
-
-    if do_evict {
-        core.request_workflow_eviction(run_id);
-    }
-    // Spam some queries (sending multiple queries after WF closed covers a possible path where
-    // we could screw-up re-applying the final WFT)
-    let mut query_futs = FuturesUnordered::new();
-    for _ in 0..3 {
-        let gw = starter.get_client().await.clone();
-        let query_fut = async move {
-            let q_resp = gw
-                .query_workflow_execution(
-                    workflow_id.to_string(),
-                    run_id.to_string(),
-                    WorkflowQuery {
-                        query_type: "myquery".to_string(),
-                        query_args: Some(b"hi".into()),
-                        header: None,
-                    },
-                )
-                .await
-                .unwrap();
-            // Ensure query response is as expected
-            assert_eq!(q_resp.unwrap()[0].data, query_resp);
-        };
-
-        query_futs.push(query_fut.boxed());
-        query_futs.push(do_workflow(true).map(|_| ()).boxed());
-    }
-    while query_futs.next().await.is_some() {}
-    drain_pollers_and_shutdown(core).await;
-}
-
-#[tokio::test]
-async fn fail_legacy_query() {
-    let query_err = "oh no broken";
-    let mut starter = init_core_and_create_wf("fail_legacy_query").await;
-    let core = starter.get_worker().await;
-    let workflow_id = starter.get_task_queue().to_string();
-    let task = core.poll_workflow_activation().await.unwrap();
-    let t1_resp = vec![
-        StartTimer {
-            seq: 1,
-            start_to_fire_timeout: Some(prost_dur!(from_millis(500))),
-        }
-        .into(),
-        StartTimer {
-            seq: 2,
-            start_to_fire_timeout: Some(prost_dur!(from_secs(3))),
-        }
-        .into(),
-    ];
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        task.run_id.clone(),
-        t1_resp.clone(),
-    ))
-    .await
-    .unwrap();
-    tokio::time::sleep(Duration::from_secs(1)).await;
-    // Query after timer should have fired and there should be new WFT
-    let query_fut = async {
-        starter
-            .get_client()
-            .await
-            .query_workflow_execution(
-                workflow_id.to_string(),
-                task.run_id.to_string(),
-                WorkflowQuery {
-                    query_type: "myquery".to_string(),
-                    query_args: Some(b"hi".into()),
-                    header: None,
-                },
-            )
-            .await
-            .unwrap_err()
-    };
-    let workflow_completions_future = async {
-        // Give query a beat to get going
-        tokio::time::sleep(Duration::from_millis(400)).await;
-        // This poll *should* have the `queries` field populated, but doesn't, seemingly due to
-        // a server bug. So, complete the WF task of the first timer firing with empty commands
-        let task = core.poll_workflow_activation().await.unwrap();
-        assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-            }]
-        );
-        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            task.run_id,
-            vec![],
-        ))
-        .await
-        .unwrap();
-        let task = core.poll_workflow_activation().await.unwrap();
-        // Poll again, and we end up getting a `query` field query response
-        assert_matches!(
-            task.jobs.as_slice(),
-            [WorkflowActivationJob {
-                variant: Some(workflow_activation_job::Variant::QueryWorkflow(q)),
-            }] => q
-        );
-        // Fail this task
-        core.complete_workflow_activation(WorkflowActivationCompletion::fail(
-            task.run_id,
-            Failure {
-                message: query_err.to_string(),
-                ..Default::default()
-            },
-        ))
-        .await
-        .unwrap();
-        // Finish the workflow (handling cache removal)
-        let task = core.poll_workflow_activation().await.unwrap();
-        core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-            .await
-            .unwrap();
-        let task = core.poll_workflow_activation().await.unwrap();
-        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            task.run_id,
-            t1_resp.clone(),
-        ))
-        .await
-        .unwrap();
-        let task = core.poll_workflow_activation().await.unwrap();
-        core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
-            .await
-            .unwrap();
-        let task = core.poll_workflow_activation().await.unwrap();
-        core.complete_execution(&task.run_id).await;
-    };
-    let (q_resp, _) = tokio::join!(query_fut, workflow_completions_future);
-    // Ensure query response is a failure and has the right message
-    assert_eq!(q_resp.message(), query_err);
-}

data/bridge/sdk-core/tests/integ_tests/visibility_tests.rs

@@ -1,151 +0,0 @@
-use assert_matches::assert_matches;
-use std::{sync::Arc, time::Duration};
-use temporal_client::{
-    ListClosedFilters, ListOpenFilters, Namespace, RegisterNamespaceOptions, StartTimeFilter,
-    WorkflowClientTrait, WorkflowExecutionFilter,
-};
-use temporal_sdk_core_protos::coresdk::workflow_activation::{
-    workflow_activation_job, WorkflowActivationJob,
-};
-use temporal_sdk_core_test_utils::{
-    drain_pollers_and_shutdown, get_integ_server_options, CoreWfStarter, WorkerTestHelpers,
-    NAMESPACE,
-};
-use tokio::time::sleep;
-
-#[tokio::test]
-async fn client_list_open_closed_workflow_executions() {
-    let wf_name = "client_list_open_closed_workflow_executions".to_owned();
-    let mut starter = CoreWfStarter::new(&wf_name);
-    let core = starter.get_worker().await;
-    let client = starter.get_client().await;
-
-    let earliest = std::time::SystemTime::now();
-    let latest = earliest + Duration::from_secs(60);
-
-    // start workflow
-    let run_id = starter.start_wf_with_id(wf_name.to_owned()).await;
-    let task = core.poll_workflow_activation().await.unwrap();
-    assert_matches!(
-        task.jobs.as_slice(),
-        [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
-        }]
-    );
-
-    // List above OPEN workflow
-    let start_time_filter = StartTimeFilter {
-        earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
-        latest_time: Some(latest).and_then(|t| t.try_into().ok()),
-    };
-    let filter = ListOpenFilters::ExecutionFilter(WorkflowExecutionFilter {
-        workflow_id: wf_name.clone(),
-        run_id: "".to_owned(),
-    });
-    let open_workflows = client
-        .list_open_workflow_executions(1, Default::default(), Some(start_time_filter), Some(filter))
-        .await
-        .unwrap();
-    assert_eq!(open_workflows.executions.len(), 1);
-    let workflow = open_workflows.executions[0].clone();
-    assert_eq!(workflow.execution.as_ref().unwrap().workflow_id, wf_name);
-
-    // Complete workflow
-    core.complete_execution(&task.run_id).await;
-    drain_pollers_and_shutdown(&core).await;
-
-    // List above CLOSED workflow. Visibility doesn't always update immediately so we give this a
-    // few tries.
-    let mut passed = false;
-    for _ in 1..=5 {
-        let closed_workflows = client
-            .list_closed_workflow_executions(
-                1,
-                Default::default(),
-                Some(StartTimeFilter {
-                    earliest_time: Some(earliest).and_then(|t| t.try_into().ok()),
-                    latest_time: Some(latest).and_then(|t| t.try_into().ok()),
-                }),
-                Some(ListClosedFilters::ExecutionFilter(
-                    WorkflowExecutionFilter {
-                        workflow_id: wf_name.clone(),
-                        run_id: run_id.clone(),
-                    },
-                )),
-            )
-            .await
-            .unwrap();
-        if closed_workflows.executions.len() == 1 {
-            let workflow = &closed_workflows.executions[0];
-            if workflow.execution.as_ref().unwrap().workflow_id == wf_name {
-                passed = true;
-                break;
-            }
-        }
-        sleep(Duration::from_millis(100)).await;
-    }
-    assert!(passed);
-}
-
-#[tokio::test]
-async fn client_create_namespace() {
-    let client = Arc::new(
-        get_integ_server_options()
-            .connect(NAMESPACE.to_owned(), None, None)
-            .await
-            .expect("Must connect"),
-    );
-
-    let register_options = RegisterNamespaceOptions::builder()
-        .namespace("test-create-namespace")
-        .description("it's alive")
-        .build()
-        .unwrap();
-
-    client
-        .register_namespace(register_options.clone())
-        .await
-        .unwrap();
-
-    //#Hack, not sure how else to wait for a proper response.  RegisterNamespace isn't safe to read
-    //after write
-    let mut attempts = 0;
-    let wait_time = Duration::from_secs(1);
-    loop {
-        attempts += 1;
-        let resp = client
-            .describe_namespace(Namespace::Name(register_options.namespace.clone()))
-            .await;
-
-        match resp {
-            Ok(n) => {
-                let namespace_info = n.namespace_info.unwrap();
-                assert_eq!(namespace_info.name, register_options.namespace);
-                assert_eq!(namespace_info.description, register_options.description);
-                return;
-            }
-            _ => {
-                if attempts == 12 {
-                    panic!("failed to query registered namespace");
-                }
-                sleep(wait_time).await
-            }
-        }
-    }
-}
-
-#[tokio::test]
-async fn client_describe_namespace() {
-    let client = Arc::new(
-        get_integ_server_options()
-            .connect(NAMESPACE.to_owned(), None, None)
-            .await
-            .expect("Must connect"),
-    );
-
-    let namespace_result = client
-        .describe_namespace(Namespace::Name(NAMESPACE.to_owned()))
-        .await
-        .unwrap();
-    assert_eq!(namespace_result.namespace_info.unwrap().name, NAMESPACE);
-}