From 436baa3bda8329989c35f106ba44a26f58a95096 Mon Sep 17 00:00:00 2001
From: Zachary Hamm <zack@systeminit.com>
Date: Thu, 22 Jan 2026 14:31:31 -0600
Subject: [PATCH 1/2] chore: only start required servers per test

Adds arguments to the dal test macro that enable and disable specific
"servers" per test. By default, only the rebaser and pinga will be
started, and you can enable the rest with:

  enable_veritech
  enable_edda
  enable_forklift

Note that I have not enabled edda for any test, and all tests pass, so
it looks like we don't have any real integration testing for edda at the
moment.

The one you'll want the most is enable_veritech, which you should be
sure to enable any time you will have to execute functions.

This took about 10-30 seconds off my test runs.
---
 lib/dal/tests/integration_test/action.rs      |  8 +--
 .../integration_test/action/schema_level.rs   |  2 +-
 lib/dal/tests/integration_test/asset.rs       |  2 +-
 .../tests/integration_test/attribute_value.rs |  4 +-
 .../attribute_value/subscription.rs           | 38 ++++++-------
 .../subscription/default_subscriptions.rs     |  4 +-
 lib/dal/tests/integration_test/attributes.rs  | 16 +++---
 .../tests/integration_test/audit_logging.rs   |  2 +-
 .../{schema/variant => }/authoring.rs         |  0
 .../variant => }/authoring/clone_variant.rs   |  2 +-
 .../variant => }/authoring/create_variant.rs  |  2 +-
 .../authoring/delete_unlocked_variant.rs      |  2 +-
 .../variant => }/authoring/regenerate.rs      |  8 +--
 .../variant => }/authoring/save_variant.rs    |  4 +-
 .../authoring/unlock_and_edit_variant.rs      |  2 +-
 .../variant => }/authoring/update_variant.rs  |  8 +--
 lib/dal/tests/integration_test/component.rs   | 14 ++---
 .../component/autosubscribe.rs                | 30 +++++-----
 .../integration_test/component/delete.rs      | 10 ++--
 .../integration_test/component/duplicate.rs   | 12 ++--
 .../integration_test/component/get_code.rs    |  6 +-
 .../integration_test/component/get_diff.rs    |  6 +-
 .../tests/integration_test/component/paste.rs | 14 ++---
 .../component/property_order.rs               |  8 +--
 .../integration_test/component/upgrade.rs     | 18 +++---
 .../integration_test/cycle_check_guard.rs     | 10 ++--
 .../func/authoring/binding/attribute.rs       |  6 +-
 .../func/authoring/create_func.rs             | 18 +++---
 .../func/authoring/test_execute.rs            | 10 ++--
 lib/dal/tests/integration_test/func/debug.rs  |  4 +-
 lib/dal/tests/integration_test/management.rs  | 38 ++++++-------
 .../integration_test/materialized_views.rs    | 12 ++--
 lib/dal/tests/integration_test/mod.rs         |  1 +
 .../integration_test/node_weight/action.rs    |  4 +-
 lib/dal/tests/integration_test/pkg/mod.rs     |  8 +--
 lib/dal/tests/integration_test/prop.rs        | 10 ++--
 .../tests/integration_test/qualifications.rs  |  2 +-
 .../integration_test/resource_metadata.rs     |  2 +-
 lib/dal/tests/integration_test/schema/leaf.rs |  4 +-
 .../tests/integration_test/schema/variant.rs  |  1 -
 lib/dal/tests/integration_test/secret.rs      | 16 +++---
 .../integration_test/secret/with_actions.rs   |  2 +-
 .../secret/with_schema_variant_authoring.rs   |  2 +-
 .../integration_test/summary_generator.rs     |  2 +-
 lib/dal/tests/integration_test/validations.rs | 12 ++--
 lib/dal/tests/integration_test/view.rs        | 12 ++--
 lib/si-test-macros/src/dal_test.rs            | 25 ++++++---
 lib/si-test-macros/src/lib.rs                 | 55 ++++++++++++++++++-
 48 files changed, 269 insertions(+), 209 deletions(-)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring.rs (100%)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring/clone_variant.rs (98%)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring/create_variant.rs (98%)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring/delete_unlocked_variant.rs (98%)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring/regenerate.rs (99%)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring/save_variant.rs (99%)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring/unlock_and_edit_variant.rs (99%)
 rename lib/dal/tests/integration_test/{schema/variant => }/authoring/update_variant.rs (99%)

diff --git a/lib/dal/tests/integration_test/action.rs b/lib/dal/tests/integration_test/action.rs
index 2a3120532b..77173f1b0b 100644
--- a/lib/dal/tests/integration_test/action.rs
+++ b/lib/dal/tests/integration_test/action.rs
@@ -134,7 +134,7 @@ async fn set_state(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn run(ctx: &mut DalContext) -> Result<()> {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "swifty", "shake it off")
@@ -190,7 +190,7 @@ async fn auto_queue_creation(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn auto_queue_update(ctx: &mut DalContext) -> Result<()> {
     // ======================================================
     // Creating a component  should enqueue a create action
@@ -327,7 +327,7 @@ async fn auto_queue_update(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn refresh_actions_run_where_they_should(ctx: &mut DalContext) -> Result<()> {
     // small even schema can be used to test this!
     // First, we'll create a new component and apply (and wait for the create action to run)
@@ -436,7 +436,7 @@ async fn refresh_actions_run_where_they_should(ctx: &mut DalContext) -> Result<(
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn resource_value_propagation_subscriptions_works(ctx: &mut DalContext) -> Result<()> {
     // create 2 variants A & B where A has a resource_value prop that B is subscribed to
     let component_a_code_definition = r#"
diff --git a/lib/dal/tests/integration_test/action/schema_level.rs b/lib/dal/tests/integration_test/action/schema_level.rs
index b1d4f015e3..760a2b3bd4 100644
--- a/lib/dal/tests/integration_test/action/schema_level.rs
+++ b/lib/dal/tests/integration_test/action/schema_level.rs
@@ -22,7 +22,7 @@ use dal_test::{
 };
 use pretty_assertions_sorted::assert_eq;
 
-#[test]
+#[test(enable_veritech)]
 async fn schema_level_action_prototype(ctx: &mut DalContext) -> Result<()> {
     let schema = Schema::get_by_name(ctx, "swifty").await?;
     let default_schema_variant_id = Schema::default_variant_id(ctx, schema.id()).await?;
diff --git a/lib/dal/tests/integration_test/asset.rs b/lib/dal/tests/integration_test/asset.rs
index bb8a25b1e5..54a5441c95 100644
--- a/lib/dal/tests/integration_test/asset.rs
+++ b/lib/dal/tests/integration_test/asset.rs
@@ -15,7 +15,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn asset_func_execution_papercuts(ctx: &mut DalContext) {
     let (schema_name, unstable_schema_variant_id) = {
         let schema_variant = VariantAuthoringClient::create_schema_and_variant(
diff --git a/lib/dal/tests/integration_test/attribute_value.rs b/lib/dal/tests/integration_test/attribute_value.rs
index bc64a041ac..911d33d5a9 100644
--- a/lib/dal/tests/integration_test/attribute_value.rs
+++ b/lib/dal/tests/integration_test/attribute_value.rs
@@ -45,7 +45,7 @@ async fn arguments_for_prototype_function_execution(ctx: &mut DalContext) -> Res
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn attribute_value_path(ctx: &mut DalContext) -> Result<()> {
     // Create a component and commit. For context, the test exclusive schema has the identity
     // function set on "/root/domain/name" with an input from "/root/si/name". We need to ensure
@@ -128,7 +128,7 @@ async fn attribute_value_path(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_object_multiplayer(ctx: &mut DalContext) -> Result<()> {
     // Create a variant that will be in all three change sets
     variant::create(
diff --git a/lib/dal/tests/integration_test/attribute_value/subscription.rs b/lib/dal/tests/integration_test/attribute_value/subscription.rs
index aab6946484..b7c59bbe3c 100644
--- a/lib/dal/tests/integration_test/attribute_value/subscription.rs
+++ b/lib/dal/tests/integration_test/attribute_value/subscription.rs
@@ -27,7 +27,7 @@ use si_id::ComponentId;
 pub mod default_subscriptions;
 
 // AV subscribes to name AV on same component
-#[test]
+#[test(enable_veritech)]
 async fn subscribe_to_name_on_same_component(ctx: &mut DalContext) -> Result<()> {
     // Make a variant with a Value prop
     variant::create(
@@ -75,7 +75,7 @@ async fn subscribe_to_name_on_same_component(ctx: &mut DalContext) -> Result<()>
 }
 
 // AV subscribes to AV on same component
-#[test]
+#[test(enable_veritech)]
 async fn subscribe_to_string(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -118,7 +118,7 @@ async fn subscribe_to_string(ctx: &mut DalContext) -> Result<()> {
 }
 
 // AV subscribes to array element of another AV
-#[test]
+#[test(enable_veritech)]
 async fn subscribe_to_array_element(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -164,7 +164,7 @@ async fn subscribe_to_array_element(ctx: &mut DalContext) -> Result<()> {
 }
 
 // AV subscribes to map element of another AV
-#[test]
+#[test(enable_veritech)]
 async fn subscribe_to_map_element(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -214,7 +214,7 @@ async fn subscribe_to_map_element(ctx: &mut DalContext) -> Result<()> {
 }
 
 // Two different subscriptions to different values on the same component (tests dirty logic)
-#[test]
+#[test(enable_veritech)]
 async fn subscribe_to_two_values(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -275,7 +275,7 @@ async fn subscribe_to_two_values(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_component_with_subscriptions_correction(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -332,7 +332,7 @@ async fn delete_component_with_subscriptions_correction(ctx: &mut DalContext) ->
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn array_subscription(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -367,7 +367,7 @@ async fn array_subscription(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn array_item_subscriptions(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -411,7 +411,7 @@ async fn array_item_subscriptions(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_object_to_map(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -443,7 +443,7 @@ async fn subscription_object_to_map(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_map_to_object(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -475,7 +475,7 @@ async fn subscription_map_to_object(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_json_to_string(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -502,7 +502,7 @@ async fn subscription_json_to_string(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_string_to_json(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -529,7 +529,7 @@ async fn subscription_string_to_json(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_type_mismatch_array_to_single(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -554,7 +554,7 @@ async fn subscription_type_mismatch_array_to_single(ctx: &mut DalContext) -> Res
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_type_mismatch_single_to_array(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -579,7 +579,7 @@ async fn subscription_type_mismatch_single_to_array(ctx: &mut DalContext) -> Res
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_subscribed_to_array_item(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -634,7 +634,7 @@ async fn delete_subscribed_to_array_item(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscribe_with_custom_function(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
     let func = FuncAuthoringClient::create_new_transformation_func(
@@ -692,7 +692,7 @@ async fn subscribe_with_custom_function(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn remove_subscribed_component(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
 
@@ -738,7 +738,7 @@ async fn remove_subscribed_component(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_cycles(ctx: &mut DalContext) -> Result<()> {
     create_testy_variant(ctx).await?;
     component::create(ctx, "testy", "subscriber").await?;
@@ -863,7 +863,7 @@ fn extract_edges(graph: &SubscriptionGraph) -> BTreeSet<(ComponentId, ComponentI
     edges
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_graph_constructors_produce_identical_results(
     ctx: &mut DalContext,
 ) -> Result<()> {
diff --git a/lib/dal/tests/integration_test/attribute_value/subscription/default_subscriptions.rs b/lib/dal/tests/integration_test/attribute_value/subscription/default_subscriptions.rs
index 0fc0f099d8..3a595e7af5 100644
--- a/lib/dal/tests/integration_test/attribute_value/subscription/default_subscriptions.rs
+++ b/lib/dal/tests/integration_test/attribute_value/subscription/default_subscriptions.rs
@@ -30,7 +30,7 @@ use dal_test::{
 };
 use pretty_assertions_sorted::assert_eq;
 
-#[test]
+#[test(enable_veritech)]
 async fn test_set_as_default_subscription_source(ctx: &DalContext) -> Result<()> {
     let (_, _, default_dest_a_variant_id, _) = variants_with_prop_suggestions(ctx).await?;
 
@@ -234,7 +234,7 @@ async fn test_set_as_default_subscription_source(ctx: &DalContext) -> Result<()>
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn test_is_same_type_as(ctx: &DalContext) -> Result<()> {
     variants_with_prop_suggestions(ctx).await?;
 
diff --git a/lib/dal/tests/integration_test/attributes.rs b/lib/dal/tests/integration_test/attributes.rs
index 14cb72f3cc..14627885c3 100644
--- a/lib/dal/tests/integration_test/attributes.rs
+++ b/lib/dal/tests/integration_test/attributes.rs
@@ -41,7 +41,7 @@ use si_events::{
 
 // Test that updating attributes sets them (and their parents) correctly, but leaves default
 // values and other values alone.
-#[test]
+#[test(enable_veritech)]
 async fn update_attributes(ctx: &DalContext) -> Result<()> {
     variant::create(
         ctx,
@@ -131,7 +131,7 @@ async fn update_attributes(ctx: &DalContext) -> Result<()> {
 
 // Test that updating an attribute value via the new subscription interface correctly enqueues
 // update actions
-#[test]
+#[test(enable_veritech)]
 async fn update_attributes_enqueues_update_fn(ctx: &mut DalContext) -> Result<()> {
     // ======================================================
     // Creating a component  should enqueue a create action
@@ -229,7 +229,7 @@ async fn update_attributes_enqueues_update_fn(ctx: &mut DalContext) -> Result<()
 
 // Test that attribute updates are processed in the order they are specified sets them (and their parents) correctly, but leaves default
 // values and other values alone.
-#[test]
+#[test(enable_veritech)]
 async fn update_attributes_runs_in_order_and_allows_duplicates(ctx: &mut DalContext) -> Result<()> {
     variant::create(
         ctx,
@@ -282,7 +282,7 @@ async fn update_attributes_runs_in_order_and_allows_duplicates(ctx: &mut DalCont
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_attributes_serializes_json(ctx: &mut DalContext) -> Result<()> {
     variant::create(
         ctx,
@@ -357,7 +357,7 @@ async fn update_attributes_serializes_json(ctx: &mut DalContext) -> Result<()> {
 
 // Test that attribute updates are processed in the order they are specified sets them (and their parents) correctly, but leaves default
 // values and other values alone.
-#[test]
+#[test(enable_veritech)]
 async fn component_sources_in_order(ctx: &mut DalContext) -> Result<()> {
     variant::create(
         ctx,
@@ -495,7 +495,7 @@ async fn component_sources_in_order(ctx: &mut DalContext) -> Result<()> {
 
 // Test that updating attributes sets them (and their parents) correctly, but leaves default
 // values and other values alone.
-#[test]
+#[test(enable_veritech)]
 async fn update_attribute_child_of_subscription(ctx: &mut DalContext) -> Result<()> {
     variant::create(
         ctx,
@@ -649,7 +649,7 @@ async fn update_attribute_child_of_subscription(ctx: &mut DalContext) -> Result<
 /// This tests the fix for a bug where use_default_prototype was calling update(None)
 /// which created a si:Unset component prototype BEFORE removing the manual override,
 /// causing the component prototype to remain instead of reverting to the schema variant prototype.
-#[test]
+#[test(enable_veritech)]
 async fn unset_manual_override_reverts_to_default(ctx: &mut DalContext) -> Result<()> {
     // Create a schema with a default value
     variant::create(
@@ -732,7 +732,7 @@ async fn unset_manual_override_reverts_to_default(ctx: &mut DalContext) -> Resul
 
 /// Test that unsetting a value that was never manually overridden creates a si:Unset component prototype.
 /// This tests the else branch of use_default_prototype where no component prototype exists.
-#[test]
+#[test(enable_veritech)]
 async fn unset_value_without_existing_override_creates_unset_prototype(
     ctx: &mut DalContext,
 ) -> Result<()> {
diff --git a/lib/dal/tests/integration_test/audit_logging.rs b/lib/dal/tests/integration_test/audit_logging.rs
index 8540471bb4..e72e74d851 100644
--- a/lib/dal/tests/integration_test/audit_logging.rs
+++ b/lib/dal/tests/integration_test/audit_logging.rs
@@ -30,7 +30,7 @@ const STREAM_RETRY_INTERVAL_MILLISECONDS: u64 = 100;
 
 const SIZE: usize = 200;
 
-#[test]
+#[test(enable_veritech, enable_forklift)]
 async fn round_trip(ctx: &mut DalContext, audit_database_context: AuditDatabaseContext) {
     let context = audit_database_context;
 
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring.rs b/lib/dal/tests/integration_test/authoring.rs
similarity index 100%
rename from lib/dal/tests/integration_test/schema/variant/authoring.rs
rename to lib/dal/tests/integration_test/authoring.rs
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring/clone_variant.rs b/lib/dal/tests/integration_test/authoring/clone_variant.rs
similarity index 98%
rename from lib/dal/tests/integration_test/schema/variant/authoring/clone_variant.rs
rename to lib/dal/tests/integration_test/authoring/clone_variant.rs
index 63779aca9a..795345c505 100644
--- a/lib/dal/tests/integration_test/schema/variant/authoring/clone_variant.rs
+++ b/lib/dal/tests/integration_test/authoring/clone_variant.rs
@@ -7,7 +7,7 @@ use dal::{
 };
 use dal_test::test;
 
-#[test]
+#[test(enable_veritech)]
 async fn clone_variant(ctx: &mut DalContext) {
     let new_change_set = ChangeSet::fork_head(ctx, "new change set")
         .await
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring/create_variant.rs b/lib/dal/tests/integration_test/authoring/create_variant.rs
similarity index 98%
rename from lib/dal/tests/integration_test/schema/variant/authoring/create_variant.rs
rename to lib/dal/tests/integration_test/authoring/create_variant.rs
index 33511cffdd..d0e28517a7 100644
--- a/lib/dal/tests/integration_test/schema/variant/authoring/create_variant.rs
+++ b/lib/dal/tests/integration_test/authoring/create_variant.rs
@@ -8,7 +8,7 @@ use dal::{
 };
 use dal_test::test;
 
-#[test]
+#[test(enable_veritech)]
 async fn create_variant(ctx: &mut DalContext) {
     let new_change_set = ChangeSet::fork_head(ctx, "new change set")
         .await
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring/delete_unlocked_variant.rs b/lib/dal/tests/integration_test/authoring/delete_unlocked_variant.rs
similarity index 98%
rename from lib/dal/tests/integration_test/schema/variant/authoring/delete_unlocked_variant.rs
rename to lib/dal/tests/integration_test/authoring/delete_unlocked_variant.rs
index 21217be364..76651d6607 100644
--- a/lib/dal/tests/integration_test/schema/variant/authoring/delete_unlocked_variant.rs
+++ b/lib/dal/tests/integration_test/authoring/delete_unlocked_variant.rs
@@ -9,7 +9,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_unlocked_variant(ctx: &mut DalContext) {
     let asset_name = "chainsawVariant".to_string();
     let description = None;
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring/regenerate.rs b/lib/dal/tests/integration_test/authoring/regenerate.rs
similarity index 99%
rename from lib/dal/tests/integration_test/schema/variant/authoring/regenerate.rs
rename to lib/dal/tests/integration_test/authoring/regenerate.rs
index 274692ff86..a06a0447c7 100644
--- a/lib/dal/tests/integration_test/schema/variant/authoring/regenerate.rs
+++ b/lib/dal/tests/integration_test/authoring/regenerate.rs
@@ -39,7 +39,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn regenerate_variant(ctx: &mut DalContext) -> Result<()> {
     ChangeSetTestHelpers::fork_from_head_change_set(ctx).await?;
     // find the variant we know is default and attached to this func already
@@ -97,7 +97,7 @@ async fn regenerate_variant(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_socket_data_on_regenerate(ctx: &mut DalContext) -> Result<()> {
     let name = "Bandit";
     let description = None;
@@ -274,7 +274,7 @@ async fn update_socket_data_on_regenerate(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn retain_bindings(ctx: &mut DalContext) -> Result<()> {
     let name = "Toto Wolff";
     let description = None;
@@ -552,7 +552,7 @@ async fn retain_bindings(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn dynamic_functions_on_new_attribute_values_are_rerun(ctx: &mut DalContext) -> Result<()> {
     let destination_schema_variant_name = "SchemaVariant Name";
     let category = "Schema Variant Category";
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring/save_variant.rs b/lib/dal/tests/integration_test/authoring/save_variant.rs
similarity index 99%
rename from lib/dal/tests/integration_test/schema/variant/authoring/save_variant.rs
rename to lib/dal/tests/integration_test/authoring/save_variant.rs
index b160f56f35..e87e92650e 100644
--- a/lib/dal/tests/integration_test/schema/variant/authoring/save_variant.rs
+++ b/lib/dal/tests/integration_test/authoring/save_variant.rs
@@ -14,7 +14,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn save_variant(ctx: &mut DalContext) {
     let new_change_set = ChangeSet::fork_head(ctx, "new change set")
         .await
@@ -122,7 +122,7 @@ async fn save_variant(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn unlock_and_save_variant(ctx: &mut DalContext) {
     let new_change_set = ChangeSet::fork_head(ctx, "new change set")
         .await
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring/unlock_and_edit_variant.rs b/lib/dal/tests/integration_test/authoring/unlock_and_edit_variant.rs
similarity index 99%
rename from lib/dal/tests/integration_test/schema/variant/authoring/unlock_and_edit_variant.rs
rename to lib/dal/tests/integration_test/authoring/unlock_and_edit_variant.rs
index 87137ad0b1..cdd300b042 100644
--- a/lib/dal/tests/integration_test/schema/variant/authoring/unlock_and_edit_variant.rs
+++ b/lib/dal/tests/integration_test/authoring/unlock_and_edit_variant.rs
@@ -9,7 +9,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn create_variant_merge_unlock_and_edit(ctx: &mut DalContext) {
     let asset_name = "chainsawVariant".to_string();
     let description = None;
diff --git a/lib/dal/tests/integration_test/schema/variant/authoring/update_variant.rs b/lib/dal/tests/integration_test/authoring/update_variant.rs
similarity index 99%
rename from lib/dal/tests/integration_test/schema/variant/authoring/update_variant.rs
rename to lib/dal/tests/integration_test/authoring/update_variant.rs
index f553cda8b4..5a6edc8f6a 100644
--- a/lib/dal/tests/integration_test/schema/variant/authoring/update_variant.rs
+++ b/lib/dal/tests/integration_test/authoring/update_variant.rs
@@ -38,7 +38,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn update_variant(ctx: &mut DalContext) {
     // Let's create a new asset
     let asset_name = "paulsTestAsset".to_string();
@@ -174,7 +174,7 @@ async fn update_variant(ctx: &mut DalContext) {
     assert_eq!(updated_default_schema_variant, second_updated_sv_id);
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_variant_with_new_metadata(ctx: &mut DalContext) {
     // Let's create a new asset with some initial metadata
     let asset_name = "paulsTestAsset".to_string();
@@ -512,7 +512,7 @@ async fn update_variant_with_new_metadata(ctx: &mut DalContext) {
     assert_eq!(second_diagram_component.display_name, second_component_name);
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_variant_with_new_prototypes_for_new_func(ctx: &mut DalContext) {
     let first_variant = VariantAuthoringClient::create_schema_and_variant(
         ctx,
@@ -682,7 +682,7 @@ async fn update_variant_with_new_prototypes_for_new_func(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_variant_with_leaf_func(ctx: &mut DalContext) {
     let schema_variant = VariantAuthoringClient::create_schema_and_variant(
         ctx,
diff --git a/lib/dal/tests/integration_test/component.rs b/lib/dal/tests/integration_test/component.rs
index df9166e426..f9dbba04ae 100644
--- a/lib/dal/tests/integration_test/component.rs
+++ b/lib/dal/tests/integration_test/component.rs
@@ -46,7 +46,7 @@ mod property_order;
 mod set_type;
 mod upgrade;
 
-#[test]
+#[test(enable_veritech)]
 async fn update_and_insert_and_update(ctx: &mut DalContext) -> Result<()> {
     let component = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -166,7 +166,7 @@ async fn update_and_insert_and_update(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_and_determine_lineage(ctx: &DalContext) -> Result<()> {
     // List all schemas in the workspace. Pick the first one alphabetically.
     let mut schemas: Vec<Schema> = Schema::list(ctx).await?;
@@ -221,7 +221,7 @@ async fn create_and_determine_lineage(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn through_the_wormholes_simple(ctx: &mut DalContext) -> Result<()> {
     let name = "across the universe";
     let component =
@@ -379,7 +379,7 @@ async fn through_the_wormholes_simple(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn through_the_wormholes_child_value_reactivity(ctx: &mut DalContext) -> Result<()> {
     let name = "across the universe";
     let component =
@@ -521,7 +521,7 @@ async fn through_the_wormholes_child_value_reactivity(ctx: &mut DalContext) -> R
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn set_the_universe(ctx: &mut DalContext) -> Result<()> {
     let component = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -580,7 +580,7 @@ async fn set_the_universe(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 #[ignore = "this test does not pass on the legacy snapshot because id is not included in the node hash"]
 async fn change_component_id(ctx: &mut DalContext) -> Result<()> {
     let component = create_component_for_default_schema_name_in_default_view(
@@ -621,7 +621,7 @@ async fn change_component_id(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn default_values_appear_in_views(ctx: &mut DalContext) -> Result<()> {
     let _subscription_tracker = variant::create(
         ctx,
diff --git a/lib/dal/tests/integration_test/component/autosubscribe.rs b/lib/dal/tests/integration_test/component/autosubscribe.rs
index f265e55d0a..1fda5e7e18 100644
--- a/lib/dal/tests/integration_test/component/autosubscribe.rs
+++ b/lib/dal/tests/integration_test/component/autosubscribe.rs
@@ -18,7 +18,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use serde_json::json;
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_basic_suggest_sources(ctx: &mut DalContext) -> Result<()> {
     // Test basic functionality where one component has a prop with "suggestSources"
     // pointing to another component's prop, and values match
@@ -109,7 +109,7 @@ async fn autosubscribe_basic_suggest_sources(ctx: &mut DalContext) -> Result<()>
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_basic_suggest_as_source_for(ctx: &mut DalContext) -> Result<()> {
     // Test basic functionality where one component has a prop with "suggestAsSourceFor"
     // pointing to another component's prop, and values match
@@ -171,7 +171,7 @@ async fn autosubscribe_basic_suggest_as_source_for(ctx: &mut DalContext) -> Resu
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_no_matching_values(ctx: &mut DalContext) -> Result<()> {
     // Test that subscriptions are NOT created when prop suggestions exist
     // but values don't match
@@ -233,7 +233,7 @@ async fn autosubscribe_no_matching_values(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_multiple_matches_conflict(ctx: &mut DalContext) -> Result<()> {
     // Test conflict resolution when multiple components could be sources
     // for the same destination prop (should return conflicts, not create subscriptions)
@@ -309,7 +309,7 @@ async fn autosubscribe_multiple_matches_conflict(ctx: &mut DalContext) -> Result
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_single_match_from_multiple_candidates(ctx: &mut DalContext) -> Result<()> {
     // Test that when multiple candidates exist but only one has matching values,
     // a subscription is created with that one
@@ -395,7 +395,7 @@ async fn autosubscribe_single_match_from_multiple_candidates(ctx: &mut DalContex
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_mixed_explicit_and_implicit_suggestions(ctx: &mut DalContext) -> Result<()> {
     // Test component with some props having explicit suggestSources and others
     // relying on implicit suggestAsSourceFor from other components
@@ -516,7 +516,7 @@ async fn autosubscribe_mixed_explicit_and_implicit_suggestions(ctx: &mut DalCont
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_no_suggestions_no_subscriptions(ctx: &mut DalContext) -> Result<()> {
     // Test that components without any prop suggestions don't create subscriptions
 
@@ -557,7 +557,7 @@ async fn autosubscribe_no_suggestions_no_subscriptions(ctx: &mut DalContext) ->
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_schema_mismatch(ctx: &mut DalContext) -> Result<()> {
     // Test that suggestions pointing to non-existent schemas/wrong schemas
     // don't create subscriptions
@@ -609,7 +609,7 @@ async fn autosubscribe_schema_mismatch(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_prop_path_mismatch(ctx: &mut DalContext) -> Result<()> {
     // Test that suggestions pointing to non-existent prop paths don't create subscriptions
 
@@ -660,7 +660,7 @@ async fn autosubscribe_prop_path_mismatch(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_array_values(ctx: &mut DalContext) -> Result<()> {
     // Test autosubscribe behavior with array values
 
@@ -765,7 +765,7 @@ async fn autosubscribe_array_values(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_object_values(ctx: &mut DalContext) -> Result<()> {
     // Test autosubscribe behavior with complex object values
 
@@ -898,7 +898,7 @@ async fn autosubscribe_object_values(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_multiple_props_same_component(ctx: &mut DalContext) -> Result<()> {
     // Test component with multiple props that could have subscriptions
 
@@ -999,7 +999,7 @@ async fn autosubscribe_multiple_props_same_component(ctx: &mut DalContext) -> Re
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_between_two_components(ctx: &mut DalContext) -> Result<()> {
     // Test handling of circular suggestion relationships
 
@@ -1077,7 +1077,7 @@ async fn autosubscribe_between_two_components(ctx: &mut DalContext) -> Result<()
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_existing_subscription_skip(ctx: &mut DalContext) -> Result<()> {
     // Test that existing subscriptions are not overwritten or duplicated
 
@@ -1147,7 +1147,7 @@ async fn autosubscribe_existing_subscription_skip(ctx: &mut DalContext) -> Resul
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn autosubscribe_cycle_detection_prevents_cycles(ctx: &mut DalContext) -> Result<()> {
     // Test that cycle detection prevents circular subscription chains between components
     // with self-referencing suggestions. At most 1 subscription should be created to
diff --git a/lib/dal/tests/integration_test/component/delete.rs b/lib/dal/tests/integration_test/component/delete.rs
index 22a0003153..fbe1b2ba41 100644
--- a/lib/dal/tests/integration_test/component/delete.rs
+++ b/lib/dal/tests/integration_test/component/delete.rs
@@ -38,7 +38,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use veritech_client::ResourceStatus;
 
-#[test]
+#[test(enable_veritech)]
 async fn delete(ctx: &mut DalContext) {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "swifty", "shake it off")
@@ -58,7 +58,7 @@ async fn delete(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_enqueues_destroy_action(ctx: &mut DalContext) {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "dummy-secret", "component")
@@ -110,7 +110,7 @@ async fn delete_enqueues_destroy_action(ctx: &mut DalContext) {
     assert_eq!(1, action_ids.len());
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_on_already_to_delete_does_not_enqueue_destroy_action(ctx: &mut DalContext) {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "dummy-secret", "component")
@@ -188,7 +188,7 @@ async fn delete_on_already_to_delete_does_not_enqueue_destroy_action(ctx: &mut D
 
 // dependent_values_update::marked_for_deletion_to_normal_is_blocked tests delete downstream values
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_multiple_components(ctx: &mut DalContext) -> Result<()> {
     ChangeSetTestHelpers::fork_from_head_change_set(ctx).await?;
 
@@ -317,7 +317,7 @@ async fn delete_multiple_components(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_multiple_components_with_subscriptions(ctx: &mut DalContext) -> Result<()> {
     // Create a component B that feeds 2 other components A via subscription
     // Run Create actions for 2 components A
diff --git a/lib/dal/tests/integration_test/component/duplicate.rs b/lib/dal/tests/integration_test/component/duplicate.rs
index 2a4e3c2704..c67c7a5726 100644
--- a/lib/dal/tests/integration_test/component/duplicate.rs
+++ b/lib/dal/tests/integration_test/component/duplicate.rs
@@ -17,7 +17,7 @@ use crate::integration_test::component::connectable_test::{
     SubscribableTest,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_component_with_value(ctx: &mut DalContext) -> Result<()> {
     let component = ExpectComponent::create_named(ctx, "pirate", "Long John Silver").await;
     let parrots = component
@@ -53,7 +53,7 @@ async fn duplicate_component_with_value(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_components_with_subscriptions(ctx: &mut DalContext) -> Result<()> {
     let test = SubscribableTest::setup(ctx).await?;
 
@@ -175,7 +175,7 @@ async fn duplicate_components_with_subscriptions(ctx: &mut DalContext) -> Result
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_manager_and_managed(ctx: &mut DalContext) -> Result<()> {
     let test = SubscribableTest::setup(ctx).await?;
 
@@ -217,7 +217,7 @@ async fn duplicate_manager_and_managed(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_manager_only(ctx: &mut DalContext) -> Result<()> {
     let test = SubscribableTest::setup(ctx).await?;
 
@@ -258,7 +258,7 @@ async fn duplicate_manager_only(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_managed_only(ctx: &mut DalContext) -> Result<()> {
     let test = SubscribableTest::setup(ctx).await?;
 
@@ -298,7 +298,7 @@ async fn duplicate_managed_only(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_preserves_external_and_recreates_internal_subscriptions(
     ctx: &mut DalContext,
 ) -> Result<()> {
diff --git a/lib/dal/tests/integration_test/component/get_code.rs b/lib/dal/tests/integration_test/component/get_code.rs
index b2dcc978a5..f35e88d3d8 100644
--- a/lib/dal/tests/integration_test/component/get_code.rs
+++ b/lib/dal/tests/integration_test/component/get_code.rs
@@ -12,7 +12,7 @@ use dal_test::{
 };
 use pretty_assertions_sorted::assert_eq;
 
-#[test]
+#[test(enable_veritech)]
 async fn get_code_json_lang(ctx: &mut DalContext) {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "swifty", "shake it off")
@@ -42,7 +42,7 @@ async fn get_code_json_lang(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn get_code_yaml_and_string(ctx: &mut DalContext) {
     let component = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -85,7 +85,7 @@ async fn get_code_yaml_and_string(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn get_code_no_codegen_funcs(ctx: &mut DalContext) {
     let starfield_component = create_component_for_default_schema_name_in_default_view(
         ctx,
diff --git a/lib/dal/tests/integration_test/component/get_diff.rs b/lib/dal/tests/integration_test/component/get_diff.rs
index 20f3365cc1..1ea8009580 100644
--- a/lib/dal/tests/integration_test/component/get_diff.rs
+++ b/lib/dal/tests/integration_test/component/get_diff.rs
@@ -14,7 +14,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use serde_json::Value;
 
-#[test]
+#[test(enable_veritech)]
 async fn get_diff_new_component(ctx: &mut DalContext) {
     let starfield_component = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -45,7 +45,7 @@ async fn get_diff_new_component(ctx: &mut DalContext) {
     assert_eq!(expected, inner_diff.code);
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn get_diff_component_no_changes_from_head(ctx: &mut DalContext) {
     let starfield_component = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -99,7 +99,7 @@ async fn get_diff_component_no_changes_from_head(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn get_diff_component_change_comp_type(ctx: &mut DalContext) {
     let starfield_component = create_component_for_default_schema_name_in_default_view(
         ctx,
diff --git a/lib/dal/tests/integration_test/component/paste.rs b/lib/dal/tests/integration_test/component/paste.rs
index e4fc57baad..dd4c00624f 100644
--- a/lib/dal/tests/integration_test/component/paste.rs
+++ b/lib/dal/tests/integration_test/component/paste.rs
@@ -22,7 +22,7 @@ use crate::integration_test::component::connectable_test::{
     GEOMETRY2,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn paste_component_with_value(ctx: &mut DalContext) -> Result<()> {
     let component = ExpectComponent::create_named(ctx, "pirate", "Long John Silver").await;
     let parrots = component
@@ -66,7 +66,7 @@ async fn paste_component_with_value(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn paste_components_with_subscriptions(ctx: &mut DalContext) -> Result<()> {
     let test = ConnectableTest::setup(ctx).await?;
 
@@ -271,7 +271,7 @@ async fn paste_components_with_subscriptions(ctx: &mut DalContext) -> Result<()>
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn paste_components_with_subscriptions_opposite_order(ctx: &mut DalContext) -> Result<()> {
     let test = ConnectableTest::setup(ctx).await?;
 
@@ -476,7 +476,7 @@ async fn paste_components_with_subscriptions_opposite_order(ctx: &mut DalContext
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn paste_manager_and_managed(ctx: &mut DalContext) -> Result<()> {
     let test = ConnectableTest::setup(ctx).await?;
 
@@ -518,7 +518,7 @@ async fn paste_manager_and_managed(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn paste_manager_and_managed_opposite_order(ctx: &mut DalContext) -> Result<()> {
     let test = ConnectableTest::setup(ctx).await?;
 
@@ -560,7 +560,7 @@ async fn paste_manager_and_managed_opposite_order(ctx: &mut DalContext) -> Resul
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn paste_manager(ctx: &mut DalContext) -> Result<()> {
     let test = ConnectableTest::setup(ctx).await?;
 
@@ -595,7 +595,7 @@ async fn paste_manager(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn paste_managed(ctx: &mut DalContext) -> Result<()> {
     let test = ConnectableTest::setup(ctx).await?;
 
diff --git a/lib/dal/tests/integration_test/component/property_order.rs b/lib/dal/tests/integration_test/component/property_order.rs
index 4ee8c02caa..38e1914afc 100644
--- a/lib/dal/tests/integration_test/component/property_order.rs
+++ b/lib/dal/tests/integration_test/component/property_order.rs
@@ -138,7 +138,7 @@ async fn create_test_object_prop_order_schema(
 const EXPECT_ABCDEF: [&str; 6] = ["a", "b", "c", "d", "e", "f"];
 const EXPECT_FEDCBA: [&str; 6] = ["f", "e", "d", "c", "b", "a"];
 
-#[test]
+#[test(enable_veritech)]
 async fn property_order_remains_after_update(ctx: &mut DalContext) -> dal_test::Result<()> {
     // Validate that props are in schema defined order
     let abcdef_schema = create_abcdef_schema(ctx).await?;
@@ -176,7 +176,7 @@ async fn property_order_remains_after_update(ctx: &mut DalContext) -> dal_test::
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn child_property_order_remains_after_update(ctx: &mut DalContext) -> dal_test::Result<()> {
     // Validate that props are in schema defined order
     let variant = create_test_object_prop_order_schema(ctx).await?;
@@ -212,7 +212,7 @@ async fn child_property_order_remains_after_update(ctx: &mut DalContext) -> dal_
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn child_property_order_remains_after_upgrade(ctx: &mut DalContext) -> dal_test::Result<()> {
     // Validate that props are in schema defined order
     let variant = create_test_object_prop_order_schema(ctx).await?;
@@ -268,7 +268,7 @@ async fn child_property_order_remains_after_upgrade(ctx: &mut DalContext) -> dal
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn child_property_value_remains_after_update_and_paste(
     ctx: &mut DalContext,
 ) -> dal_test::Result<()> {
diff --git a/lib/dal/tests/integration_test/component/upgrade.rs b/lib/dal/tests/integration_test/component/upgrade.rs
index c0b55dcdfe..e6cf76711c 100644
--- a/lib/dal/tests/integration_test/component/upgrade.rs
+++ b/lib/dal/tests/integration_test/component/upgrade.rs
@@ -54,7 +54,7 @@ use crate::integration_test::component::connectable_test::ConnectableTest;
 // TODO test that validates that components that exist on locked variants aren't auto upgraded, but can be upgraded manually
 
 // Components that exist on the unlocked variant get auto upgraded when it gets regenerated
-#[test]
+#[test(enable_veritech)]
 async fn auto_upgrade_component(ctx: &mut DalContext) -> Result<()> {
     // Let's create a new asset
     let variant_zero = VariantAuthoringClient::create_schema_and_variant(
@@ -286,7 +286,7 @@ async fn auto_upgrade_component(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_component_type(ctx: &mut DalContext) -> Result<()> {
     //
     // Create a new schema and variant set to component_type: ConfigurationFrameDown
@@ -346,7 +346,7 @@ async fn upgrade_component_type(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_component_type_after_explicit_set(ctx: &mut DalContext) -> Result<()> {
     //
     // Create a new schema and variant set to component_type: ConfigurationFrameDown
@@ -403,7 +403,7 @@ async fn upgrade_component_type_after_explicit_set(ctx: &mut DalContext) -> Resu
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_component_attaches_overlay_func(ctx: &mut DalContext) -> Result<()> {
     let swifty = component::create(ctx, "swifty", "swifty").await?;
     let actions = dal_materialized_views::action::action_view_list::assemble(ctx.clone()).await?;
@@ -487,7 +487,7 @@ async fn upgrade_component_attaches_overlay_func(ctx: &mut DalContext) -> Result
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_unlocked_schema_variant_after_component_changes_component_type(
     ctx: &mut DalContext,
 ) -> Result<()> {
@@ -531,7 +531,7 @@ async fn create_unlocked_schema_variant_after_component_changes_component_type(
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_array_of_objects(ctx: &mut DalContext) -> Result<()> {
     let variant_code = r#"
     function main() {
@@ -704,7 +704,7 @@ async fn upgrade_array_of_objects(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_component_with_subscriptions(ctx: &mut DalContext) -> Result<()> {
     let test = ConnectableTest::setup(ctx).await?;
     test.create_connectable(ctx, "in").await?;
@@ -769,7 +769,7 @@ async fn update_schema_variant_description(
     Ok(SchemaVariant::get_by_id(ctx, variant.id).await?.into())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_component_preserves_default_subscription_source(
     ctx: &mut DalContext,
 ) -> Result<()> {
@@ -901,7 +901,7 @@ async fn upgrade_component_preserves_default_subscription_source(
 /// Test that upgrading a component with default values doesn't spuriously enqueue update actions
 /// This test verifies the fix for the issue where update actions were being enqueued even when
 /// no values actually changed during an upgrade.
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_without_value_changes_does_not_enqueue_update_action(
     ctx: &mut DalContext,
 ) -> Result<()> {
diff --git a/lib/dal/tests/integration_test/cycle_check_guard.rs b/lib/dal/tests/integration_test/cycle_check_guard.rs
index 3b3da8c029..5bf0b355c1 100644
--- a/lib/dal/tests/integration_test/cycle_check_guard.rs
+++ b/lib/dal/tests/integration_test/cycle_check_guard.rs
@@ -9,7 +9,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn cycle_check_guard_test(ctx: &DalContext) -> Result<()> {
     // Cycle check should be disabled by default
     let snap = ctx.workspace_snapshot()?;
@@ -43,7 +43,7 @@ async fn cycle_check_guard_test(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn cycle_cannot_be_created_when_cycle_check_is_enabled(ctx: &DalContext) -> Result<()> {
     variant::create(ctx, "test", TEST_ASSET_FUNCTION).await?;
     component::create(ctx, "test", "test").await?;
@@ -61,7 +61,7 @@ async fn cycle_cannot_be_created_when_cycle_check_is_enabled(ctx: &DalContext) -
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn cycle_can_be_created_when_cycle_check_is_disabled(ctx: &DalContext) -> Result<()> {
     variant::create(ctx, "test", TEST_ASSET_FUNCTION).await?;
     component::create(ctx, "test", "test").await?;
@@ -86,7 +86,7 @@ async fn cycle_can_be_created_when_cycle_check_is_disabled(ctx: &DalContext) ->
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn edges_can_be_added_when_there_is_an_existing_cycle(ctx: &DalContext) -> Result<()> {
     variant::create(ctx, "test", TEST_ASSET_FUNCTION).await?;
     component::create(ctx, "test", "test").await?;
@@ -104,7 +104,7 @@ async fn edges_can_be_added_when_there_is_an_existing_cycle(ctx: &DalContext) ->
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn cycle_cannot_be_created_when_there_is_an_existing_cycle(ctx: &DalContext) -> Result<()> {
     variant::create(ctx, "test", TEST_ASSET_FUNCTION).await?;
     component::create(ctx, "test", "test").await?;
diff --git a/lib/dal/tests/integration_test/func/authoring/binding/attribute.rs b/lib/dal/tests/integration_test/func/authoring/binding/attribute.rs
index 42d7095d28..d22d4a1ae4 100644
--- a/lib/dal/tests/integration_test/func/authoring/binding/attribute.rs
+++ b/lib/dal/tests/integration_test/func/authoring/binding/attribute.rs
@@ -40,7 +40,7 @@ pub use si_frontend_types;
 
 use crate::integration_test::func::authoring::save_func::save_func_setup;
 
-#[test]
+#[test(enable_veritech)]
 async fn create_attribute_prototype_with_attribute_prototype_argument(ctx: &mut DalContext) {
     let (func_id, _) = save_func_setup(ctx, "test:falloutEntriesToGalaxies").await;
 
@@ -564,7 +564,7 @@ async fn create_attribute_prototype_with_attribute_prototype_argument(ctx: &mut
 //     assert!(value.is_none());
 // }
 
-#[test]
+#[test(enable_veritech)]
 async fn invalid_identity_bindings(ctx: &mut DalContext) {
     // Let's create a new asset
     let asset_name = "paulsTestAsset".to_string();
@@ -834,7 +834,7 @@ async fn invalid_identity_bindings(ctx: &mut DalContext) {
     drop(cycle_check_guard);
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn detach_attribute_func(ctx: &mut DalContext) {
     ChangeSetTestHelpers::commit_and_update_snapshot_to_visibility(ctx)
         .await
diff --git a/lib/dal/tests/integration_test/func/authoring/create_func.rs b/lib/dal/tests/integration_test/func/authoring/create_func.rs
index d3bfd9053f..b0fd12434e 100644
--- a/lib/dal/tests/integration_test/func/authoring/create_func.rs
+++ b/lib/dal/tests/integration_test/func/authoring/create_func.rs
@@ -35,7 +35,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn create_qualification_with_schema_variant(ctx: &mut DalContext) {
     let swifty_schema = Schema::get_by_name(ctx, "swifty")
         .await
@@ -107,7 +107,7 @@ async fn create_qualification_with_schema_variant(ctx: &mut DalContext) {
     assert!(head_func.is_none());
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_codegen_with_schema_variant(ctx: &mut DalContext) {
     let swifty_schema = Schema::get_by_name(ctx, "swifty")
         .await
@@ -165,7 +165,7 @@ async fn create_codegen_with_schema_variant(ctx: &mut DalContext) {
     assert!(head_func.is_none());
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_attribute_override_dynamic_func_for_prop(ctx: &mut DalContext) {
     let schema = Schema::get_by_name(ctx, "swifty")
         .await
@@ -239,7 +239,7 @@ async fn create_attribute_override_dynamic_func_for_prop(ctx: &mut DalContext) {
     assert!(head_func.is_none());
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_attribute_override_dynamic_func_for_output_socket(ctx: &mut DalContext) {
     let schema = Schema::get_by_name(ctx, "swifty")
         .await
@@ -310,7 +310,7 @@ async fn create_attribute_override_dynamic_func_for_output_socket(ctx: &mut DalC
     assert!(head_func.is_none());
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_action_with_schema_variant(ctx: &mut DalContext) {
     let swifty_schema = Schema::get_by_name(ctx, "small even lego")
         .await
@@ -371,7 +371,7 @@ async fn create_action_with_schema_variant(ctx: &mut DalContext) {
     assert!(head_func.is_none());
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_action_kinds_causes_error(ctx: &mut DalContext) {
     let schema_variant_id = create_unlocked_variant_copy_for_schema_name(ctx, "small even lego")
         .await
@@ -398,7 +398,7 @@ async fn duplicate_action_kinds_causes_error(ctx: &mut DalContext) {
     }
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_func_name_in_different_schema_variants_is_ok(ctx: &mut DalContext) {
     let schema_variant_id = create_unlocked_variant_copy_for_schema_name(ctx, "katy perry")
         .await
@@ -430,7 +430,7 @@ async fn duplicate_func_name_in_different_schema_variants_is_ok(ctx: &mut DalCon
     .expect("unable to create second func");
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn duplicate_func_name_in_same_schema_causes_error(ctx: &mut DalContext) {
     let schema_variant_id = create_unlocked_variant_copy_for_schema_name(ctx, "katy perry")
         .await
@@ -462,7 +462,7 @@ async fn duplicate_func_name_in_same_schema_causes_error(ctx: &mut DalContext) {
     }
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_qualification_and_code_gen_with_existing_component(ctx: &mut DalContext) {
     let asset_name = "britsTestAsset".to_string();
     let description = None;
diff --git a/lib/dal/tests/integration_test/func/authoring/test_execute.rs b/lib/dal/tests/integration_test/func/authoring/test_execute.rs
index fdbb4ce74c..8b3b4f66f1 100644
--- a/lib/dal/tests/integration_test/func/authoring/test_execute.rs
+++ b/lib/dal/tests/integration_test/func/authoring/test_execute.rs
@@ -21,7 +21,7 @@ use si_events::{
     FuncRunState,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn test_execute_action_func(ctx: &mut DalContext) {
     let component_name = "Forty Six & 2";
     let func_name = "test:createActionStarfield";
@@ -61,7 +61,7 @@ async fn test_execute_action_func(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn test_execute_attribute_func(ctx: &mut DalContext) {
     let component_name = "Jimmy";
     let func_name = "test:falloutEntriesToGalaxies";
@@ -101,7 +101,7 @@ async fn test_execute_attribute_func(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn test_execute_code_generation_func(ctx: &mut DalContext) {
     let component_name = "Pushit";
     let func_name = "test:generateStringCode";
@@ -141,7 +141,7 @@ async fn test_execute_code_generation_func(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn test_execute_qualification_func(ctx: &mut DalContext) {
     let component_name = "Third Eye";
     let func_name = "test:qualificationDummySecretStringIsTodd";
@@ -181,7 +181,7 @@ async fn test_execute_qualification_func(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn test_execute_with_modified_code(ctx: &mut DalContext) {
     let component_name = "Jimmy";
     let func_name = "test:falloutEntriesToGalaxies";
diff --git a/lib/dal/tests/integration_test/func/debug.rs b/lib/dal/tests/integration_test/func/debug.rs
index cc5378985d..3f500ba51a 100644
--- a/lib/dal/tests/integration_test/func/debug.rs
+++ b/lib/dal/tests/integration_test/func/debug.rs
@@ -21,7 +21,7 @@ use dal_test::{
 };
 use veritech_client::ComponentKind;
 
-#[test]
+#[test(enable_veritech)]
 async fn test_execute_debug_func(ctx: &mut DalContext) {
     let code = r#"function debug({ component, debugInput }) {
         console.log('Debugging');
@@ -61,7 +61,7 @@ async fn test_execute_debug_func(ctx: &mut DalContext) {
     assert_eq!("test", value["output"]["b"]);
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn test_debug_func_job(ctx: &mut DalContext) {
     let code = r#"function debug({ component, debugInput }) {
         console.log('Debugging');
diff --git a/lib/dal/tests/integration_test/management.rs b/lib/dal/tests/integration_test/management.rs
index c1e59ffe1d..ee91936a28 100644
--- a/lib/dal/tests/integration_test/management.rs
+++ b/lib/dal/tests/integration_test/management.rs
@@ -93,7 +93,7 @@ async fn exec_mgmt_func(
     Ok((execution_result, result))
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn set_resource(ctx: &mut DalContext) -> Result<()> {
     // Create a schema that has mirrored resource_value + domain props
     let _test_variant_id = variant::create(
@@ -182,7 +182,7 @@ async fn set_resource(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn import_and_refresh(ctx: &mut DalContext) -> Result<()> {
     let small_even_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -291,7 +291,7 @@ async fn import_and_refresh(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_managed_components_in_view(ctx: &DalContext) -> Result<()> {
     let small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -362,7 +362,7 @@ async fn update_managed_components_in_view(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_managed_components(ctx: &DalContext) -> Result<()> {
     let small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -413,7 +413,7 @@ async fn update_managed_components(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_component_of_other_schema(ctx: &DalContext) -> Result<()> {
     let small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -488,7 +488,7 @@ async fn create_component_of_other_schema(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_component_of_same_schema(ctx: &DalContext) -> Result<()> {
     let small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -581,7 +581,7 @@ async fn create_component_of_same_schema(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn execute_management_func(ctx: &DalContext) -> Result<()> {
     let small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -631,7 +631,7 @@ async fn execute_management_func(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_in_views(ctx: &DalContext) -> Result<()> {
     let mut small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -704,7 +704,7 @@ async fn create_in_views(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_view_and_in_view(ctx: &DalContext) -> Result<()> {
     let mut small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -776,7 +776,7 @@ async fn create_view_and_in_view(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn delete_and_erase_components(ctx: &mut DalContext) -> Result<()> {
     let manager = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -911,7 +911,7 @@ async fn delete_and_erase_components(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn remove_view_and_component_from_view(ctx: &DalContext) -> Result<()> {
     let manager =
         create_component_for_default_schema_name_in_default_view(ctx, "small odd lego", "c-suite")
@@ -1027,7 +1027,7 @@ async fn remove_view_and_component_from_view(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn upgrade_manager_variant(ctx: &mut DalContext) -> Result<()> {
     // Set up management schema
     let original_variant = ExpectSchemaVariant(
@@ -1092,7 +1092,7 @@ async fn upgrade_manager_variant(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_and_subscribe_to_source(ctx: &mut DalContext) -> Result<()> {
     create_subscription_tracker_asset(ctx).await?;
 
@@ -1174,7 +1174,7 @@ async fn create_and_subscribe_to_source(ctx: &mut DalContext) -> Result<()> {
 //   if we pull it into a HashMap<name, Component>, Foo and Bar would always appear in the same
 //   order)
 
-#[test]
+#[test(enable_veritech)]
 async fn create_and_subscribe_foo_to_bar(ctx: &mut DalContext) -> Result<()> {
     create_subscription_tracker_asset(ctx).await?;
 
@@ -1241,7 +1241,7 @@ async fn create_and_subscribe_foo_to_bar(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_and_subscribe_bar_to_foo(ctx: &mut DalContext) -> Result<()> {
     create_subscription_tracker_asset(ctx).await?;
 
@@ -1308,7 +1308,7 @@ async fn create_and_subscribe_bar_to_foo(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn create_and_subscribe_foo_to_bar_reverse(ctx: &mut DalContext) -> Result<()> {
     create_subscription_tracker_asset(ctx).await?;
 
@@ -1376,7 +1376,7 @@ async fn create_and_subscribe_foo_to_bar_reverse(ctx: &mut DalContext) -> Result
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn management_execution_state_db_test(ctx: &mut DalContext) -> Result<()> {
     let small_odd_lego = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -1515,7 +1515,7 @@ async fn management_execution_state_db_test(ctx: &mut DalContext) -> Result<()>
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn management_func_autosubscribe(ctx: &mut DalContext) -> Result<()> {
     // Create fake::region schema
     let _output = variant::create(
@@ -1900,7 +1900,7 @@ async fn create_subscription_tracker_asset(ctx: &DalContext) -> Result<SchemaVar
     Ok(subscription_tracker)
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn schema_level_management_prototypes(ctx: &mut DalContext) -> Result<()> {
     let test_variant_id = variant::create(
         ctx,
diff --git a/lib/dal/tests/integration_test/materialized_views.rs b/lib/dal/tests/integration_test/materialized_views.rs
index 9c84528a5a..c2617e232e 100644
--- a/lib/dal/tests/integration_test/materialized_views.rs
+++ b/lib/dal/tests/integration_test/materialized_views.rs
@@ -47,7 +47,7 @@ use si_frontend_mv_types::{
     reference::ReferenceKind,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn actions(ctx: &DalContext) -> Result<()> {
     let schema_name = "swifty";
     let component_name = "tes vi";
@@ -125,7 +125,7 @@ async fn actions(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn attribute_tree(ctx: &DalContext) -> Result<()> {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "swifty", "swifty").await?;
@@ -138,7 +138,7 @@ async fn attribute_tree(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn schema_variant(ctx: &DalContext) -> Result<()> {
     let schema_variant_id = SchemaVariant::default_id_for_schema_name(ctx, "swifty").await?;
 
@@ -149,7 +149,7 @@ async fn schema_variant(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn cached_schema_variant_not_found(ctx: &DalContext) -> Result<()> {
     // Use a non-existent SchemaVariantId
     let non_existent_id = SchemaVariantId::new();
@@ -166,7 +166,7 @@ async fn cached_schema_variant_not_found(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn component_diff(ctx: &mut DalContext) -> Result<()> {
     variant::create(
         ctx,
@@ -515,7 +515,7 @@ async fn expected_component_diff_mv(
     Ok(serde_json::from_str(&json)?)
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn component(ctx: &DalContext) -> Result<()> {
     let components = dal_materialized_views::component_list::assemble(ctx.clone()).await?;
     assert_eq!(
diff --git a/lib/dal/tests/integration_test/mod.rs b/lib/dal/tests/integration_test/mod.rs
index f68a3df10a..b9105e7971 100644
--- a/lib/dal/tests/integration_test/mod.rs
+++ b/lib/dal/tests/integration_test/mod.rs
@@ -4,6 +4,7 @@ mod attribute_prototype;
 mod attribute_value;
 mod attributes;
 mod audit_logging;
+mod authoring;
 mod change_set;
 mod component;
 mod cycle_check_guard;
diff --git a/lib/dal/tests/integration_test/node_weight/action.rs b/lib/dal/tests/integration_test/node_weight/action.rs
index a910624568..b2986f45e7 100644
--- a/lib/dal/tests/integration_test/node_weight/action.rs
+++ b/lib/dal/tests/integration_test/node_weight/action.rs
@@ -28,7 +28,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use si_events::ActionState;
 
-#[test]
+#[test(enable_veritech)]
 async fn prevent_orphaned_update_actions(ctx: &mut DalContext) -> Result<()> {
     // Create a component with both create and update actions and apply to HEAD.
     let component_id = component::create(ctx, "swifty", "taylor swift").await?;
@@ -87,7 +87,7 @@ async fn prevent_orphaned_update_actions(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn prevent_duplicate_exclusive_actions(ctx: &mut DalContext) -> Result<()> {
     let test_variant_id = dal_test::helpers::schema::variant::create(
         ctx,
diff --git a/lib/dal/tests/integration_test/pkg/mod.rs b/lib/dal/tests/integration_test/pkg/mod.rs
index 66223ecf1b..7129d9c7e5 100644
--- a/lib/dal/tests/integration_test/pkg/mod.rs
+++ b/lib/dal/tests/integration_test/pkg/mod.rs
@@ -44,7 +44,7 @@ use si_pkg::{
     SiPkg,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn import_pkg_from_pkg_set_latest_default(ctx: &mut DalContext) -> Result<()> {
     // Let's create a new asset
     let asset_name = "imanasset".to_string();
@@ -133,7 +133,7 @@ async fn import_pkg_from_pkg_set_latest_default(ctx: &mut DalContext) -> Result<
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn prop_order_preserved(ctx: &mut DalContext) -> Result<()> {
     let expected_props = vec![
         "foo",
@@ -314,7 +314,7 @@ fn spec_prop_child_names(parent_prop: &PropSpec, prefix: Option<&str>) -> Vec<St
 
 /// Test that `import_funcs_for_module_update` correctly handles intrinsic functions.
 /// Intrinsic functions should be looked up by name rather than recreated.
-#[test]
+#[test(enable_veritech)]
 async fn import_funcs_for_module_update_handles_intrinsics(ctx: &mut DalContext) -> Result<()> {
     // Create a schema with variant
     let asset_name = "upgrade_test_asset".to_string();
@@ -376,7 +376,7 @@ async fn import_funcs_for_module_update_handles_intrinsics(ctx: &mut DalContext)
 }
 
 /// Test that `import_func` with UpdateExisting mode updates an existing func's code.
-#[test]
+#[test(enable_veritech)]
 async fn import_func_with_update_existing_updates_code(ctx: &mut DalContext) -> Result<()> {
     // Create a schema with variant (this creates a SchemaVariantDefinition func)
     let asset_name = "update_existing_test".to_string();
diff --git a/lib/dal/tests/integration_test/prop.rs b/lib/dal/tests/integration_test/prop.rs
index c747891ac2..de0a0cf50b 100644
--- a/lib/dal/tests/integration_test/prop.rs
+++ b/lib/dal/tests/integration_test/prop.rs
@@ -21,7 +21,7 @@ use itertools::Itertools as _;
 use pretty_assertions_sorted::assert_eq;
 use serde_json::json;
 
-#[test]
+#[test(enable_veritech)]
 async fn prop_path(ctx: &DalContext) -> Result<()> {
     let variant = SchemaVariant::default_for_schema_name(ctx, "starfield").await?;
 
@@ -34,7 +34,7 @@ async fn prop_path(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn verify_prop_used_as_input_flag(ctx: &DalContext) -> Result<()> {
     let variant_id = SchemaVariant::default_id_for_schema_name(ctx, "pirate").await?;
 
@@ -79,7 +79,7 @@ async fn verify_prop_used_as_input_flag(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn ordered_child_props(ctx: &DalContext) -> Result<()> {
     let variant_id = SchemaVariant::default_id_for_schema_name(ctx, "starfield").await?;
 
@@ -117,7 +117,7 @@ async fn ordered_child_props(ctx: &DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn prop_documentation(ctx: &mut DalContext) -> Result<()> {
     let name = "Toto Wolff";
     let description = None;
@@ -295,7 +295,7 @@ async fn prop_documentation(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn prop_suggestions(ctx: &DalContext) -> Result<()> {
     let foo = variant::create(
         ctx,
diff --git a/lib/dal/tests/integration_test/qualifications.rs b/lib/dal/tests/integration_test/qualifications.rs
index 9b1cf44ee5..60ea266da2 100644
--- a/lib/dal/tests/integration_test/qualifications.rs
+++ b/lib/dal/tests/integration_test/qualifications.rs
@@ -22,7 +22,7 @@ use pretty_assertions_sorted::assert_eq;
 
 const DUMMY_OUTPUT_STREAM_VIEW_LINE: &str = "[THIS IS FAKE DATA]";
 
-#[test]
+#[test(enable_veritech)]
 async fn list_qualifications(ctx: &mut DalContext) {
     let component = create_component_for_default_schema_name_in_default_view(
         ctx,
diff --git a/lib/dal/tests/integration_test/resource_metadata.rs b/lib/dal/tests/integration_test/resource_metadata.rs
index 942458eadc..71cc7b88a9 100644
--- a/lib/dal/tests/integration_test/resource_metadata.rs
+++ b/lib/dal/tests/integration_test/resource_metadata.rs
@@ -22,7 +22,7 @@ use si_events::{
     ResourceStatus,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn list(ctx: &mut DalContext, nw: &WorkspaceSignup) -> Result<()> {
     component::create(ctx, "dummy-secret", "source").await?;
     component::create(ctx, "fallout", "destination").await?;
diff --git a/lib/dal/tests/integration_test/schema/leaf.rs b/lib/dal/tests/integration_test/schema/leaf.rs
index 0cca005b41..fa79d8dff2 100644
--- a/lib/dal/tests/integration_test/schema/leaf.rs
+++ b/lib/dal/tests/integration_test/schema/leaf.rs
@@ -26,7 +26,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use tokio::sync::RwLock;
 
-#[test]
+#[test(enable_veritech)]
 async fn leaf_prototype_rerun(ctx: &mut DalContext) -> Result<()> {
     let schema = Schema::get_by_name(ctx, "swifty").await?;
 
@@ -123,7 +123,7 @@ async fn leaf_prototype_rerun(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn leaf_prototype_tests(ctx: &mut DalContext) -> Result<()> {
     let schema = Schema::get_by_name(ctx, "swifty").await?;
 
diff --git a/lib/dal/tests/integration_test/schema/variant.rs b/lib/dal/tests/integration_test/schema/variant.rs
index 23968baed7..a89552c5fa 100644
--- a/lib/dal/tests/integration_test/schema/variant.rs
+++ b/lib/dal/tests/integration_test/schema/variant.rs
@@ -16,7 +16,6 @@ use dal_test::{
 };
 use pretty_assertions_sorted::assert_eq;
 
-mod authoring;
 mod view;
 
 #[test]
diff --git a/lib/dal/tests/integration_test/secret.rs b/lib/dal/tests/integration_test/secret.rs
index eaf3c0370c..7154917bf5 100644
--- a/lib/dal/tests/integration_test/secret.rs
+++ b/lib/dal/tests/integration_test/secret.rs
@@ -36,7 +36,7 @@ use serde_json::Value;
 mod with_actions;
 mod with_schema_variant_authoring;
 
-#[test]
+#[test(enable_veritech)]
 async fn new(ctx: &DalContext, nw: &WorkspaceSignup) {
     let name = generate_fake_name().expect("could not generate fake name");
 
@@ -75,7 +75,7 @@ async fn new(ctx: &DalContext, nw: &WorkspaceSignup) {
     assert_eq!(secret, found_secret);
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn encrypt_decrypt_round_trip(ctx: &DalContext, nw: &WorkspaceSignup) {
     let pkey = nw.key_pair.public_key();
     let name = generate_fake_name().expect("could not generate fake name");
@@ -125,7 +125,7 @@ async fn encrypt_decrypt_round_trip(ctx: &DalContext, nw: &WorkspaceSignup) {
     assert_eq!(message, actual_message);
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_metadata_and_encrypted_contents(ctx: &DalContext, nw: &WorkspaceSignup) {
     let pkey = nw.key_pair.public_key();
     let key_pair_pk = nw.key_pair.pk();
@@ -280,7 +280,7 @@ async fn update_metadata_and_encrypted_contents(ctx: &DalContext, nw: &Workspace
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn copy_paste_component_with_secrets_being_used(
     ctx: &mut DalContext,
     nw: &WorkspaceSignup,
@@ -342,7 +342,7 @@ async fn copy_paste_component_with_secrets_being_used(
 
 // TODO it's unclear how / whether this should work this way with subscriptions
 #[ignore]
-#[test]
+#[test(enable_veritech)]
 async fn consumed_secrets_work_when_dvu_not_up_to_date(
     ctx: &mut DalContext,
     nw: &WorkspaceSignup,
@@ -441,7 +441,7 @@ async fn consumed_secrets_work_when_dvu_not_up_to_date(
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn update_encrypted_contents_with_dependent_values(
     ctx: &mut DalContext,
     nw: &WorkspaceSignup,
@@ -619,7 +619,7 @@ async fn update_encrypted_contents_with_dependent_values(
     );
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn secret_definition_works_with_dummy_qualification(
     ctx: &mut DalContext,
     nw: &WorkspaceSignup,
@@ -758,7 +758,7 @@ fn prepare_decrypted_secret_for_assertions(decrypted_secret: &DecryptedSecret) -
     decrypted_value["message"].to_owned()
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn secret_definition_daisy_chain_subscriptions(ctx: &mut DalContext, nw: &WorkspaceSignup) {
     // Create secret that secret defining component uses and commit.
     let dummy = ExpectComponent::create(ctx, "dummy-secret").await;
diff --git a/lib/dal/tests/integration_test/secret/with_actions.rs b/lib/dal/tests/integration_test/secret/with_actions.rs
index cf53faa4e4..8d174f9f1e 100644
--- a/lib/dal/tests/integration_test/secret/with_actions.rs
+++ b/lib/dal/tests/integration_test/secret/with_actions.rs
@@ -28,7 +28,7 @@ use dal_test::{
 };
 use pretty_assertions_sorted::assert_eq;
 
-#[test]
+#[test(enable_veritech)]
 async fn create_action_using_secret(ctx: &mut DalContext, nw: &WorkspaceSignup) {
     // Create the components we need and commit.
     let source_component =
diff --git a/lib/dal/tests/integration_test/secret/with_schema_variant_authoring.rs b/lib/dal/tests/integration_test/secret/with_schema_variant_authoring.rs
index d2b4b1d3f0..9cedadfc45 100644
--- a/lib/dal/tests/integration_test/secret/with_schema_variant_authoring.rs
+++ b/lib/dal/tests/integration_test/secret/with_schema_variant_authoring.rs
@@ -19,7 +19,7 @@ use dal_test::{
     test,
 };
 
-#[test]
+#[test(enable_veritech)]
 async fn existing_code_gen_func_using_secrets_for_new_schema_variant(ctx: &mut DalContext) {
     // Create a new schema variant and commit.
     let schema_variant = VariantAuthoringClient::create_schema_and_variant(
diff --git a/lib/dal/tests/integration_test/summary_generator.rs b/lib/dal/tests/integration_test/summary_generator.rs
index e3dc71165b..2771dd1f23 100644
--- a/lib/dal/tests/integration_test/summary_generator.rs
+++ b/lib/dal/tests/integration_test/summary_generator.rs
@@ -13,7 +13,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use serde_json::json;
 
-#[test]
+#[test(enable_veritech)]
 async fn generate_component_summaries(ctx: &mut DalContext) -> Result<()> {
     // Create three variants for a subscription daisy chain.
     variant::create(
diff --git a/lib/dal/tests/integration_test/validations.rs b/lib/dal/tests/integration_test/validations.rs
index 15e62f8904..7055909ad0 100644
--- a/lib/dal/tests/integration_test/validations.rs
+++ b/lib/dal/tests/integration_test/validations.rs
@@ -32,7 +32,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use serde_json::json;
 
-#[test]
+#[test(enable_veritech)]
 async fn validation_format_errors(ctx: &mut DalContext) -> Result<()> {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "BadValidations", "bad")
@@ -143,7 +143,7 @@ async fn prop_editor_validation(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn validation_pre_post_mgmt_func(ctx: &mut DalContext) -> Result<()> {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "ValidatedOutput", "Output")
@@ -451,7 +451,7 @@ async fn validation_qualification(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn required_unset_value(ctx: &mut DalContext) -> Result<()> {
     ExpectSchemaVariant::create_named(
         ctx,
@@ -514,7 +514,7 @@ async fn required_unset_value(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn required_default_value(ctx: &mut DalContext) -> Result<()> {
     ExpectSchemaVariant::create_named(
         ctx,
@@ -574,7 +574,7 @@ async fn required_default_value(ctx: &mut DalContext) -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_with_unresolved_value_skips_validation_on_update(
     ctx: &mut DalContext,
 ) -> Result<()> {
@@ -698,7 +698,7 @@ async fn subscription_with_unresolved_value_skips_validation_on_update(
     Ok(())
 }
 
-#[test]
+#[test(enable_veritech)]
 async fn subscription_with_unresolved_value_skips_validation_on_component_creation(
     ctx: &mut DalContext,
 ) -> Result<()> {
diff --git a/lib/dal/tests/integration_test/view.rs b/lib/dal/tests/integration_test/view.rs
index 2d05cd1f36..78ebc60561 100644
--- a/lib/dal/tests/integration_test/view.rs
+++ b/lib/dal/tests/integration_test/view.rs
@@ -26,7 +26,7 @@ use dal_test::{
 use pretty_assertions_sorted::assert_eq;
 use si_frontend_types::RawGeometry;
 
-#[test]
+#[test(skip_rebaser, skip_pinga)]
 async fn create_view_and_component(ctx: &mut DalContext) {
     let alternative_view = ExpectView::create(ctx).await;
 
@@ -62,7 +62,7 @@ async fn create_view_and_component(ctx: &mut DalContext) {
     )
 }
 
-#[test]
+#[test(skip_rebaser, skip_pinga)]
 async fn deleting_component_deletes_geometries(ctx: &mut DalContext) {
     let component =
         create_component_for_default_schema_name_in_default_view(ctx, "swifty", "shake it off")
@@ -121,7 +121,7 @@ async fn deleting_component_deletes_geometries(ctx: &mut DalContext) {
     assert_eq!(another_diagram.components.len(), 0);
 }
 
-#[test]
+#[test(skip_rebaser, skip_pinga)]
 async fn remove_view_with_no_components(ctx: &mut DalContext) {
     let new_view = ExpectView::create(ctx).await;
 
@@ -163,7 +163,7 @@ async fn remove_view_with_no_components(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(skip_rebaser, skip_pinga, skip_veritech)]
 async fn remove_view_with_no_exclusive_components(ctx: &mut DalContext) {
     let component = create_component_for_default_schema_name_in_default_view(
         ctx,
@@ -212,7 +212,7 @@ async fn remove_view_with_no_exclusive_components(ctx: &mut DalContext) {
     );
 }
 
-#[test]
+#[test(skip_rebaser, skip_pinga, skip_veritech)]
 async fn remove_view_with_exclusive_components(ctx: &mut DalContext) {
     let new_view = ExpectView::create(ctx).await;
 
@@ -256,7 +256,7 @@ async fn remove_view_with_exclusive_components(ctx: &mut DalContext) {
     assert_eq!(vec![Ulid::from(component.id())], orphans,);
 }
 
-#[test]
+#[test(skip_rebaser, skip_pinga, skip_veritech)]
 async fn remove_view_with_removal_of_exclusive_components(ctx: &mut DalContext) {
     let new_view = ExpectView::create(ctx).await;
 
diff --git a/lib/si-test-macros/src/dal_test.rs b/lib/si-test-macros/src/dal_test.rs
index 8781612308..4119f212ea 100644
--- a/lib/si-test-macros/src/dal_test.rs
+++ b/lib/si-test-macros/src/dal_test.rs
@@ -37,19 +37,30 @@ use crate::{
 };
 
 pub(crate) fn expand(item: ItemFn, args: Args) -> TokenStream {
-    let fn_setup = fn_setup(item.sig.inputs.iter());
+    let fn_setup = fn_setup(item.sig.inputs.iter(), &args);
 
     expand_test(item, args, fn_setup)
 }
 
-fn fn_setup<'a>(params: impl Iterator<Item = &'a FnArg>) -> DalTestFnSetup {
+fn fn_setup<'a>(params: impl Iterator<Item = &'a FnArg>, args: &Args) -> DalTestFnSetup {
     let mut expander = DalTestFnSetupExpander::new();
 
-    expander.setup_start_forklift_server();
-    expander.setup_start_veritech_server();
-    expander.setup_start_pinga_server();
-    expander.setup_start_edda_server();
-    expander.setup_start_rebaser_server();
+    // Conditionally start servers based on macro arguments
+    if args.should_start_server("forklift") {
+        expander.setup_start_forklift_server();
+    }
+    if args.should_start_server("veritech") {
+        expander.setup_start_veritech_server();
+    }
+    if args.should_start_server("pinga") {
+        expander.setup_start_pinga_server();
+    }
+    if args.should_start_server("edda") {
+        expander.setup_start_edda_server();
+    }
+    if args.should_start_server("rebaser") {
+        expander.setup_start_rebaser_server();
+    }
 
     for param in params {
         match param {
diff --git a/lib/si-test-macros/src/lib.rs b/lib/si-test-macros/src/lib.rs
index 8d90e10813..fa175a3bc8 100644
--- a/lib/si-test-macros/src/lib.rs
+++ b/lib/si-test-macros/src/lib.rs
@@ -26,12 +26,34 @@ const SPAN_EVENTS_ENV_VAR: &str = "SI_TEST_LOG_SPAN_EVENTS";
 const RT_DEFAULT_WORKER_THREADS: usize = 2;
 const RT_DEFAULT_THREAD_STACK_SIZE: usize = 2 * 1024 * 1024 * 3;
 
-#[allow(dead_code)] // We aren't current using args on the macro, but when we do we can drop this
-// line
 struct Args {
     pub(crate) vars: HashSet<Ident>,
 }
 
+const DEFAULT_SERVERS: &[&str] = &["rebaser", "pinga"];
+
+impl Args {
+    /// Check if a specific server should be disabled
+    pub(crate) fn should_skip_server(&self, server_name: &str) -> bool {
+        let skip_ident = format!("skip_{server_name}");
+        self.vars.iter().any(|v| v == &skip_ident)
+    }
+
+    pub(crate) fn should_enable_server(&self, server_name: &str) -> bool {
+        let skip_ident = format!("enable_{server_name}");
+        self.vars.iter().any(|v| v == &skip_ident)
+    }
+
+    /// Check if a specific server should be started
+    pub(crate) fn should_start_server(&self, server_name: &str) -> bool {
+        if DEFAULT_SERVERS.contains(&server_name) {
+            !self.should_skip_server(server_name)
+        } else {
+            self.should_enable_server(server_name)
+        }
+    }
+}
+
 impl Parse for Args {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let vars = Punctuated::<Ident, Token![,]>::parse_terminated(input)?;
@@ -55,7 +77,34 @@ fn path_as_string(path: &Path) -> String {
 /// `#[tokio::test]` attribute provided by Tokio, and even the `#[test_log::test]` attribute which
 /// configures optional tracing/logging output.
 ///
-/// # Examples
+/// # Server Control Options
+///
+/// By default, *ONLY* rebaser and pnga are started before each test.
+///  You can control which servers are started using macro arguments:
+///
+/// ## Enable optional Servers
+///
+/// * `enable_forklift` - Enable the forklift (audit log processing and billing etc.) server
+/// * `enable_veritech` - Enable the veritech (function execution) server
+/// * `enable_edda` - Enable the edda (event streaming) server
+///
+/// ## Skip default Servers
+///
+/// Skip specific servers that aren't needed for your test:
+///
+/// ```ignore
+/// use dal::DalContext;
+/// use dal_test::test;
+///
+/// #[test(skip_rebaser, skip_pinga)]
+/// async fn test_without_rebaser(ctx: &mut DalContext) {
+///     // Runs without rebaser and pinga servers
+/// }
+/// ```
+///
+/// Available skip options:
+/// * `skip_pinga` - Skip the pinga (event processing) server
+/// * `skip_rebaser` - Skip the rebaser (change set rebasing) server
 ///
 /// ## Optional Support for Results
 ///

From fd0273166732f0dda12ee2c4983c6aa669be4917 Mon Sep 17 00:00:00 2001
From: Zachary Hamm <zack@systeminit.com>
Date: Thu, 22 Jan 2026 16:49:36 -0600
Subject: [PATCH 2/2] chore: read_wait_for_memory should check disk/durable
 first

In read_wait_for_memory we spin checking if the requested object has
landed in the memory cache (via the events stream) and then we look at
disk and durable storage. This adds a 2+ second overhead for many
fetches, which either are not about to land in the memory cache because
they are for old objects which have been evicted, or because we just
don't propagate data fast enough across NATS for it to land.

Checking the normal read path before trying to spin has a huge
performance result for the integration tests, easily 100 seconds faster
in CI, and will likely have a positive impact throughout the stack.
---
 lib/si-layer-cache/src/db/change_batch.rs       | 4 ++++
 lib/si-layer-cache/src/db/rebase_batch.rs       | 4 ++++
 lib/si-layer-cache/src/db/workspace_snapshot.rs | 4 ++++
 3 files changed, 12 insertions(+)

diff --git a/lib/si-layer-cache/src/db/change_batch.rs b/lib/si-layer-cache/src/db/change_batch.rs
index 9e235feab6..23cf57e5b4 100644
--- a/lib/si-layer-cache/src/db/change_batch.rs
+++ b/lib/si-layer-cache/src/db/change_batch.rs
@@ -110,6 +110,10 @@ impl ChangeBatchDb {
     ) -> LayerDbResult<Option<Arc<ChangeBatch>>> {
         let span = current_span_for_instrument_at!("debug");
 
+        if let Some(batch) = self.cache.get(key.to_string().into()).await? {
+            return Ok(Some(batch));
+        }
+
         let key: Arc<str> = key.to_string().into();
         const MAX_TRIES: i32 = 2000;
         let mut interval = tokio::time::interval(tokio::time::Duration::from_millis(1));
diff --git a/lib/si-layer-cache/src/db/rebase_batch.rs b/lib/si-layer-cache/src/db/rebase_batch.rs
index 794d3e57f8..a85eff1973 100644
--- a/lib/si-layer-cache/src/db/rebase_batch.rs
+++ b/lib/si-layer-cache/src/db/rebase_batch.rs
@@ -114,6 +114,10 @@ where
         let span = current_span_for_instrument_at!("debug");
 
         let key: Arc<str> = key.to_string().into();
+        if let Some(batch) = self.cache.get(key.to_string().into()).await? {
+            return Ok(Some(batch));
+        }
+
         const MAX_TRIES: i32 = 2000;
         let mut interval = tokio::time::interval(tokio::time::Duration::from_millis(1));
         let mut tried = 0;
diff --git a/lib/si-layer-cache/src/db/workspace_snapshot.rs b/lib/si-layer-cache/src/db/workspace_snapshot.rs
index a3c88daba1..eb55311f99 100644
--- a/lib/si-layer-cache/src/db/workspace_snapshot.rs
+++ b/lib/si-layer-cache/src/db/workspace_snapshot.rs
@@ -122,6 +122,10 @@ where
         let span = current_span_for_instrument_at!("debug");
 
         let key: Arc<str> = key.to_string().into();
+        if let Some(snap) = self.cache.get(key.to_string().into()).await? {
+            return Ok(Some(snap));
+        }
+
         const MAX_TRIES: i32 = 2000;
         let mut interval = tokio::time::interval(tokio::time::Duration::from_millis(1));
         let mut tried = 0;