[4/N] feat(sqsim): add scenario DSL and registry

sqsim/BUILD.bazel

@@ -0,0 +1,36 @@
+load("@rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "behavior.go",
+        "buildrunner.go",
+        "fault.go",
+        "land.go",
+        "merger.go",
+        "scenario.go",
+        "types.go",
+        "validation.go",
+    ],
+    importpath = "github.com/uber/submitqueue/sqsim",
+    visibility = ["//visibility:public"],
+    deps = ["//sqsim/entity:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "behavior_test.go",
+        "buildrunner_test.go",
+        "fault_test.go",
+        "land_test.go",
+        "merger_test.go",
+        "scenario_test.go",
+        "validation_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "@com_github_stretchr_testify//assert:go_default_library",
+        "@com_github_stretchr_testify//require:go_default_library",
+    ],
+)

sqsim/behavior.go

@@ -0,0 +1,97 @@
+// Copyright (c) 2026 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sqsim
+
+import (
+	"fmt"
+
+	"github.com/uber/submitqueue/sqsim/entity"
+)
+
+// BehaviorBuilder constructs the external behavior attached to one or more Lands.
+type BehaviorBuilder struct {
+	buildRunner        *BuildRunnerBehaviorBuilder
+	mergeConflictCheck *MergeConflictCheckBehaviorBuilder
+	merge              *MergeBehaviorBuilder
+}
+
+// NewBehavior returns an empty behavior builder.
+func NewBehavior() *BehaviorBuilder {
+	return &BehaviorBuilder{}
+}
+
+// BuildRunner sets the build behavior.
+func (b *BehaviorBuilder) BuildRunner(behavior *BuildRunnerBehaviorBuilder) *BehaviorBuilder {
+	b.buildRunner = behavior
+	return b
+}
+
+// MergeConflictCheck sets the dry-run mergeability behavior.
+func (b *BehaviorBuilder) MergeConflictCheck(behavior *MergeConflictCheckBehaviorBuilder) *BehaviorBuilder {
+	b.mergeConflictCheck = behavior
+	return b
+}
+
+// Merge sets the committing merge behavior.
+func (b *BehaviorBuilder) Merge(behavior *MergeBehaviorBuilder) *BehaviorBuilder {
+	b.merge = behavior
+	return b
+}
+
+func (b *BehaviorBuilder) build() (entity.Behavior, error) {
+	if b == nil {
+		return entity.Behavior{}, fmt.Errorf("behavior builder is nil")
+	}
+	if b.buildRunner == nil {
+		return entity.Behavior{}, fmt.Errorf("build runner behavior is required")
+	}
+	if b.mergeConflictCheck == nil {
+		return entity.Behavior{}, fmt.Errorf("merge conflict check behavior is required")
+	}
+	if b.merge == nil {
+		return entity.Behavior{}, fmt.Errorf("merge behavior is required")
+	}
+
+	buildRunner, err := b.buildRunner.build()
+	if err != nil {
+		return entity.Behavior{}, fmt.Errorf("build runner: %w", err)
+	}
+	mergeConflictCheck, err := b.mergeConflictCheck.build()
+	if err != nil {
+		return entity.Behavior{}, fmt.Errorf("merge conflict check: %w", err)
+	}
+	merge, err := b.merge.build()
+	if err != nil {
+		return entity.Behavior{}, fmt.Errorf("merge: %w", err)
+	}
+	return entity.Behavior{
+		BuildRunner:        buildRunner,
+		MergeConflictCheck: mergeConflictCheck,
+		Merge:              merge,
+	}, nil
+}
+
+func cloneBehavior(behavior entity.Behavior) entity.Behavior {
+	triggers := make([]entity.Invocation[entity.BuildTriggerOutcome], len(behavior.BuildRunner.Triggers))
+	for i, trigger := range behavior.BuildRunner.Triggers {
+		trigger.Outcome.Build.Timeline = append([]entity.BuildStatusPoint(nil), trigger.Outcome.Build.Timeline...)
+		trigger.Outcome.Build.StatusFaults = append([]entity.FaultOnCall(nil), trigger.Outcome.Build.StatusFaults...)
+		triggers[i] = trigger
+	}
+	behavior.BuildRunner.Triggers = triggers
+	behavior.MergeConflictCheck.Invocations = append([]entity.Invocation[entity.MergeConflictCheckOutcome](nil), behavior.MergeConflictCheck.Invocations...)
+	behavior.Merge.Invocations = append([]entity.Invocation[entity.MergeOutcome](nil), behavior.Merge.Invocations...)
+	return behavior
+}

sqsim/behavior_test.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sqsim
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestBehaviorBuilderRequiresEveryExternalOperation(t *testing.T) {
+	behavior := NewBehavior().
+		BuildRunner(SuccessfulBuildRunner()).
+		MergeConflictCheck(SuccessfulMergeConflictCheck())
+
+	_, err := NewScenario().
+		Timeout(time.Minute).
+		Land(NewLand("l1").Queue("sqsim").Behavior(behavior).Expect(RequestLanded)).
+		Build()
+	require.Error(t, err)
+}

sqsim/buildrunner.go

@@ -0,0 +1,112 @@
+// Copyright (c) 2026 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sqsim
+
+import (
+	"time"
+
+	"github.com/uber/submitqueue/sqsim/entity"
+)
+
+// BuildRunnerBehaviorBuilder constructs BuildRunner behavior.
+type BuildRunnerBehaviorBuilder struct {
+	triggers []entity.Invocation[entity.BuildTriggerOutcome]
+}
+
+// NewBuildRunnerBehavior returns an empty BuildRunner behavior builder.
+func NewBuildRunnerBehavior() *BuildRunnerBehaviorBuilder {
+	return &BuildRunnerBehaviorBuilder{}
+}
+
+// Trigger appends Trigger invocations.
+func (b *BuildRunnerBehaviorBuilder) Trigger(invocations ...entity.Invocation[entity.BuildTriggerOutcome]) *BuildRunnerBehaviorBuilder {
+	b.triggers = append(b.triggers, invocations...)
+	return b
+}
+
+// StatusFaultOnCall adds a Status fault to the most recent successful Trigger outcome.
+func (b *BuildRunnerBehaviorBuilder) StatusFaultOnCall(call int, fault Fault) *BuildRunnerBehaviorBuilder {
+	if len(b.triggers) == 0 {
+		return b
+	}
+	last := &b.triggers[len(b.triggers)-1]
+	last.Outcome.Build.StatusFaults = append(last.Outcome.Build.StatusFaults, entity.FaultOnCall{
+		Call:  call,
+		Fault: fault,
+	})
+	return b
+}
+
+func (b *BuildRunnerBehaviorBuilder) build() (entity.BuildRunnerBehavior, error) {
+	triggers := append([]entity.Invocation[entity.BuildTriggerOutcome](nil), b.triggers...)
+	for i := range triggers {
+		triggers[i].Outcome.Build.Timeline = append([]entity.BuildStatusPoint(nil), triggers[i].Outcome.Build.Timeline...)
+		triggers[i].Outcome.Build.StatusFaults = append([]entity.FaultOnCall(nil), triggers[i].Outcome.Build.StatusFaults...)
+	}
+	return entity.BuildRunnerBehavior{Triggers: triggers}, nil
+}
+
+// StatusAt returns a build status timeline point.
+func StatusAt(after time.Duration, status BuildStatus) BuildStatusPoint {
+	return entity.BuildStatusPoint{AfterMs: after.Milliseconds(), Status: status}
+}
+
+// BuildCreated returns a successful Trigger invocation with a build timeline.
+func BuildCreated(timeline ...BuildStatusPoint) entity.Invocation[entity.BuildTriggerOutcome] {
+	return entity.Invocation[entity.BuildTriggerOutcome]{
+		Outcome: entity.BuildTriggerOutcome{
+			Build: entity.BuildExecution{Timeline: append([]entity.BuildStatusPoint(nil), timeline...)},
+		},
+	}
+}
+
+// BuildCreatedWithFault returns a Trigger invocation that creates a build and then faults.
+func BuildCreatedWithFault(fault Fault, timeline ...BuildStatusPoint) entity.Invocation[entity.BuildTriggerOutcome] {
+	invocation := BuildCreated(timeline...)
+	invocation.Fault = fault
+	return invocation
+}
+
+// BuildTriggerFault returns a Trigger invocation that fails without creating a build.
+func BuildTriggerFault(fault Fault) entity.Invocation[entity.BuildTriggerOutcome] {
+	return entity.Invocation[entity.BuildTriggerOutcome]{Fault: fault}
+}
+
+// SuccessfulBuildRunner returns a build behavior that succeeds immediately.
+func SuccessfulBuildRunner() *BuildRunnerBehaviorBuilder {
+	return NewBuildRunnerBehavior().Trigger(BuildCreated(StatusAt(0, BuildSucceeded)))
+}
+
+// BuildSucceededAfter returns a build behavior that succeeds after the given duration.
+func BuildSucceededAfter(after time.Duration) *BuildRunnerBehaviorBuilder {
+	timeline := []BuildStatusPoint{StatusAt(0, BuildAccepted)}
+	if after > 0 {
+		timeline = append(timeline, StatusAt(after, BuildSucceeded))
+	} else {
+		timeline[0] = StatusAt(0, BuildSucceeded)
+	}
+	return NewBuildRunnerBehavior().Trigger(BuildCreated(timeline...))
+}
+
+// BuildFailedAfter returns a build behavior that fails after the given duration.
+func BuildFailedAfter(after time.Duration) *BuildRunnerBehaviorBuilder {
+	timeline := []BuildStatusPoint{StatusAt(0, BuildAccepted)}
+	if after > 0 {
+		timeline = append(timeline, StatusAt(after, BuildFailed))
+	} else {
+		timeline[0] = StatusAt(0, BuildFailed)
+	}
+	return NewBuildRunnerBehavior().Trigger(BuildCreated(timeline...))
+}

sqsim/buildrunner_test.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2026 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sqsim
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBuildRunnerBuilderAddsStatusFault(t *testing.T) {
+	builder := NewBuildRunnerBehavior().
+		Trigger(BuildCreated(
+			StatusAt(0, BuildAccepted),
+			StatusAt(time.Second, BuildSucceeded),
+		)).
+		StatusFaultOnCall(2, RetryableErrorBeforeSideEffect())
+
+	behavior, err := builder.build()
+	require.NoError(t, err)
+	require.Len(t, behavior.Triggers, 1)
+	require.Len(t, behavior.Triggers[0].Outcome.Build.StatusFaults, 1)
+	assert.Equal(t, 2, behavior.Triggers[0].Outcome.Build.StatusFaults[0].Call)
+}

sqsim/entity/BUILD.bazel

@@ -0,0 +1,24 @@
+load("@rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "behavior.go",
+        "scenario.go",
+    ],
+    importpath = "github.com/uber/submitqueue/sqsim/entity",
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "behavior_test.go",
+        "scenario_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "@com_github_stretchr_testify//assert:go_default_library",
+        "@com_github_stretchr_testify//require:go_default_library",
+    ],
+)