|
| 1 | +use temporalio_common::worker::{WorkerConfigBuilder, WorkerTaskTypes, WorkerVersioningStrategy}; |
| 2 | + |
| 3 | +fn default_versioning_strategy() -> WorkerVersioningStrategy { |
| 4 | + WorkerVersioningStrategy::None { |
| 5 | + build_id: String::new(), |
| 6 | + } |
| 7 | +} |
| 8 | + |
| 9 | +#[test] |
| 10 | +fn test_default_configuration_polls_all_types() { |
| 11 | + let config = WorkerConfigBuilder::default() |
| 12 | + .namespace("default") |
| 13 | + .task_queue("test-queue") |
| 14 | + .versioning_strategy(default_versioning_strategy()) |
| 15 | + .build() |
| 16 | + .expect("Failed to build default config"); |
| 17 | + |
| 18 | + let effective = config.effective_task_types(); |
| 19 | + assert!( |
| 20 | + effective.polls_workflows(), |
| 21 | + "Should poll workflows by default" |
| 22 | + ); |
| 23 | + assert!( |
| 24 | + effective.polls_activities(), |
| 25 | + "Should poll activities by default" |
| 26 | + ); |
| 27 | + assert!(effective.polls_nexus(), "Should poll nexus by default"); |
| 28 | +} |
| 29 | + |
| 30 | +#[test] |
| 31 | +fn test_workflow_only_worker() { |
| 32 | + let config = WorkerConfigBuilder::default() |
| 33 | + .namespace("default") |
| 34 | + .task_queue("test-queue") |
| 35 | + .versioning_strategy(default_versioning_strategy()) |
| 36 | + .task_types(WorkerTaskTypes::WORKFLOWS) |
| 37 | + .max_cached_workflows(0usize) |
| 38 | + .build() |
| 39 | + .expect("Failed to build workflow-only config"); |
| 40 | + |
| 41 | + let effective = config.effective_task_types(); |
| 42 | + assert!(effective.polls_workflows(), "Should poll workflows"); |
| 43 | + assert!(!effective.polls_activities(), "Should NOT poll activities"); |
| 44 | + assert!(!effective.polls_nexus(), "Should NOT poll nexus"); |
| 45 | +} |
| 46 | + |
| 47 | +#[test] |
| 48 | +fn test_activity_and_nexus_worker() { |
| 49 | + let config = WorkerConfigBuilder::default() |
| 50 | + .namespace("default") |
| 51 | + .task_queue("test-queue") |
| 52 | + .versioning_strategy(default_versioning_strategy()) |
| 53 | + .task_types(WorkerTaskTypes::ACTIVITIES | WorkerTaskTypes::NEXUS) |
| 54 | + .max_cached_workflows(0usize) |
| 55 | + .build() |
| 56 | + .expect("Failed to build activity+nexus config"); |
| 57 | + |
| 58 | + let effective = config.effective_task_types(); |
| 59 | + assert!(!effective.polls_workflows(), "Should NOT poll workflows"); |
| 60 | + assert!(effective.polls_activities(), "Should poll activities"); |
| 61 | + assert!(effective.polls_nexus(), "Should poll nexus"); |
| 62 | +} |
| 63 | + |
| 64 | +#[test] |
| 65 | +fn test_backward_compatibility_with_no_remote_activities() { |
| 66 | + let config = WorkerConfigBuilder::default() |
| 67 | + .namespace("default") |
| 68 | + .task_queue("test-queue") |
| 69 | + .versioning_strategy(default_versioning_strategy()) |
| 70 | + .no_remote_activities(true) |
| 71 | + .build() |
| 72 | + .expect("Failed to build config with no_remote_activities"); |
| 73 | + |
| 74 | + let effective = config.effective_task_types(); |
| 75 | + assert!(effective.polls_workflows(), "Should poll workflows"); |
| 76 | + assert!(!effective.polls_activities(), "Should NOT poll activities"); |
| 77 | + assert!(effective.polls_nexus(), "Should poll nexus"); |
| 78 | +} |
| 79 | + |
| 80 | +#[test] |
| 81 | +fn test_empty_task_types_fails_validation() { |
| 82 | + let result = WorkerConfigBuilder::default() |
| 83 | + .namespace("default") |
| 84 | + .task_queue("test-queue") |
| 85 | + .versioning_strategy(default_versioning_strategy()) |
| 86 | + .task_types(WorkerTaskTypes::empty()) |
| 87 | + .build(); |
| 88 | + |
| 89 | + assert!(result.is_err(), "Empty task_types should fail validation"); |
| 90 | + let err = result.err().unwrap().to_string(); |
| 91 | + assert!( |
| 92 | + err.contains("At least one task type"), |
| 93 | + "Error should mention task types: {err}", |
| 94 | + ); |
| 95 | +} |
| 96 | + |
| 97 | +#[test] |
| 98 | +fn test_workflow_cache_without_workflows_fails() { |
| 99 | + let result = WorkerConfigBuilder::default() |
| 100 | + .namespace("default") |
| 101 | + .task_queue("test-queue") |
| 102 | + .versioning_strategy(default_versioning_strategy()) |
| 103 | + .task_types(WorkerTaskTypes::ACTIVITIES) |
| 104 | + .max_cached_workflows(10usize) |
| 105 | + .build(); |
| 106 | + |
| 107 | + assert!( |
| 108 | + result.is_err(), |
| 109 | + "Workflow cache > 0 without workflows should fail" |
| 110 | + ); |
| 111 | + let err = result.err().unwrap().to_string(); |
| 112 | + assert!( |
| 113 | + err.contains("max_cached_workflows"), |
| 114 | + "Error should mention max_cached_workflows: {err}", |
| 115 | + ); |
| 116 | +} |
| 117 | + |
| 118 | +#[test] |
| 119 | +fn test_conflicting_no_remote_activities_and_task_types_fails() { |
| 120 | + #[allow(deprecated)] |
| 121 | + let result = WorkerConfigBuilder::default() |
| 122 | + .namespace("default") |
| 123 | + .task_queue("test-queue") |
| 124 | + .versioning_strategy(default_versioning_strategy()) |
| 125 | + .task_types(WorkerTaskTypes::ACTIVITIES) |
| 126 | + .no_remote_activities(true) |
| 127 | + .build(); |
| 128 | + |
| 129 | + assert!(result.is_err(), "Conflicting settings should fail"); |
| 130 | + |
| 131 | + let err = result.err().unwrap().to_string(); |
| 132 | + assert!( |
| 133 | + err.contains("Conflicting configuration"), |
| 134 | + "Error should mention conflict: {err}", |
| 135 | + ); |
| 136 | +} |
| 137 | + |
| 138 | +#[test] |
| 139 | +fn test_all_combinations() { |
| 140 | + let combinations = [ |
| 141 | + (WorkerTaskTypes::WORKFLOWS, "workflows only"), |
| 142 | + (WorkerTaskTypes::ACTIVITIES, "activities only"), |
| 143 | + (WorkerTaskTypes::NEXUS, "nexus only"), |
| 144 | + ( |
| 145 | + WorkerTaskTypes::WORKFLOWS | WorkerTaskTypes::ACTIVITIES, |
| 146 | + "workflows + activities", |
| 147 | + ), |
| 148 | + ( |
| 149 | + WorkerTaskTypes::WORKFLOWS | WorkerTaskTypes::NEXUS, |
| 150 | + "workflows + nexus", |
| 151 | + ), |
| 152 | + ( |
| 153 | + WorkerTaskTypes::ACTIVITIES | WorkerTaskTypes::NEXUS, |
| 154 | + "activities + nexus", |
| 155 | + ), |
| 156 | + (WorkerTaskTypes::all(), "all types"), |
| 157 | + ]; |
| 158 | + |
| 159 | + for (task_types, description) in combinations { |
| 160 | + let config = WorkerConfigBuilder::default() |
| 161 | + .namespace("default") |
| 162 | + .task_queue("test-queue") |
| 163 | + .versioning_strategy(default_versioning_strategy()) |
| 164 | + .task_types(task_types) |
| 165 | + .build() |
| 166 | + .unwrap_or_else(|e| panic!("Failed to build config for {description}: {e:?}")); |
| 167 | + |
| 168 | + let effective = config.effective_task_types(); |
| 169 | + assert_eq!( |
| 170 | + effective, task_types, |
| 171 | + "Effective types should match for {description}", |
| 172 | + ); |
| 173 | + } |
| 174 | +} |
0 commit comments