remove redundant test

Author: chris-olszewski

crates/sdk-core/tests/integ_tests/workflow_tests/activities.rs

@@ -490,100 +490,6 @@ async fn workflow_observes_non_retryable_activity() {
     worker.run_until_done().await.unwrap();
 }
 
-#[tokio::test]
-async fn workflow_observes_non_retryable_activity_failure_builder() {
-    let mut starter =
-        CoreWfStarter::new("workflow-observes-non-retryable-activity-failure-builder");
-    starter
-        .sdk_config
-        .register_activities(NonRetryableActivityBuilderActivities);
-    let mut worker = starter.worker().await;
-
-    #[workflow]
-    #[derive(Default)]
-    struct NonRetryableActivityFailureBuilderWorkflow;
-
-    #[workflow_methods]
-    impl NonRetryableActivityFailureBuilderWorkflow {
-        #[run]
-        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
-            let err = ctx
-                .start_activity(
-                    NonRetryableActivityBuilderActivities::fail_non_retryable_with_builder,
-                    (),
-                    ActivityOptions::with_start_to_close_timeout(Duration::from_secs(5))
-                        .activity_id("non-retryable-builder-act".to_owned())
-                        .retry_policy(RetryPolicy {
-                            maximum_attempts: 3,
-                            ..Default::default()
-                        })
-                        .build(),
-                )
-                .await
-                .unwrap_err();
-
-            let ActivityExecutionError::Failed(fail_err) = err else {
-                panic!("expected activity failure, got {err:?}");
-            };
-            assert_eq!(fail_err.activity_id(), "non-retryable-builder-act");
-            assert_eq!(
-                fail_err
-                    .activity_type()
-                    .map(|activity_type| activity_type.name.as_str()),
-                Some(NonRetryableActivityBuilderActivities::fail_non_retryable_with_builder.name())
-            );
-            assert_eq!(fail_err.retry_state(), RetryState::NonRetryableFailure);
-
-            let Some(IncomingError::Application(app_err)) = fail_err.cause() else {
-                panic!("expected application failure cause, got {fail_err:?}");
-            };
-            assert_eq!(
-                app_err.type_name(),
-                Some("workflow-observed-non-retryable-builder")
-            );
-            assert!(app_err.is_non_retryable());
-            assert_eq!(app_err.category(), ApplicationErrorCategory::Benign);
-            assert_eq!(
-                app_err.to_string(),
-                "non-retryable activity failure with builder"
-            );
-            assert!(app_err.failure().is_some());
-            Ok(())
-        }
-    }
-
-    struct NonRetryableActivityBuilderActivities;
-
-    #[activities]
-    impl NonRetryableActivityBuilderActivities {
-        #[activity]
-        async fn fail_non_retryable_with_builder(
-            _ctx: ActivityContext,
-        ) -> Result<(), ActivityError> {
-            Err(ActivityError::application(
-                ApplicationFailure::builder(anyhow!("non-retryable activity failure with builder"))
-                    .type_name("workflow-observed-non-retryable-builder".to_owned())
-                    .non_retryable(true)
-                    .category(ApplicationErrorCategory::Benign)
-                    .build(),
-            ))
-        }
-    }
-
-    worker.register_workflow::<NonRetryableActivityFailureBuilderWorkflow>();
-
-    let task_queue = starter.get_task_queue().to_owned();
-    worker
-        .submit_workflow(
-            NonRetryableActivityFailureBuilderWorkflow::run,
-            (),
-            WorkflowStartOptions::new(task_queue.clone(), task_queue).build(),
-        )
-        .await
-        .unwrap();
-    worker.run_until_done().await.unwrap();
-}
-
 #[tokio::test]
 async fn activity_retry() {
     let mut starter = init_core_and_create_wf("activity_retry").await;