Files
tasks/service/history/replication/executable_noop_task_test.go
zeekay 5a601d081b rebrand: go.temporal.io/server -> github.com/hanzoai/tasks
Full module path rebrand from Temporal to Hanzo Tasks:
- go.mod module: github.com/hanzoai/tasks
- All internal Go imports updated (1906 files)
- cmd/server renamed to cmd/tasksd
- Binary name: tasksd (was temporal-server)
- Docker images: hanzoai/tasks (was temporalio/server)
- README rewritten with Hanzo Tasks branding
- LLM.md created with integration notes
- Makefile, goreleaser, CI workflows updated
- go.temporal.io/sdk and go.temporal.io/api imports preserved (separate repos)

Fork of Temporal.io (MIT license).
2026-03-19 10:36:40 -07:00

104 lines
2.7 KiB
Go

package replication
import (
"errors"
"math/rand"
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"go.temporal.io/api/serviceerror"
"github.com/hanzoai/tasks/client"
"github.com/hanzoai/tasks/common/cluster"
"github.com/hanzoai/tasks/common/log"
"github.com/hanzoai/tasks/common/metrics"
"github.com/hanzoai/tasks/common/namespace"
"github.com/hanzoai/tasks/service/history/shard"
"go.uber.org/mock/gomock"
)
type (
executableNoopTaskSuite struct {
suite.Suite
*require.Assertions
controller *gomock.Controller
clusterMetadata *cluster.MockMetadata
clientBean *client.MockBean
shardController *shard.MockController
namespaceCache *namespace.MockRegistry
metricsHandler metrics.Handler
logger log.Logger
eagerNamespaceRefresher *MockEagerNamespaceRefresher
task *ExecutableNoopTask
}
)
func TestExecutableNoopTaskSuite(t *testing.T) {
s := new(executableNoopTaskSuite)
suite.Run(t, s)
}
func (s *executableNoopTaskSuite) SetupSuite() {
s.Assertions = require.New(s.T())
}
func (s *executableNoopTaskSuite) TearDownSuite() {
}
func (s *executableNoopTaskSuite) SetupTest() {
s.controller = gomock.NewController(s.T())
s.clusterMetadata = cluster.NewMockMetadata(s.controller)
s.clientBean = client.NewMockBean(s.controller)
s.shardController = shard.NewMockController(s.controller)
s.namespaceCache = namespace.NewMockRegistry(s.controller)
s.metricsHandler = metrics.NoopMetricsHandler
s.logger = log.NewNoopLogger()
s.eagerNamespaceRefresher = NewMockEagerNamespaceRefresher(s.controller)
s.task = NewExecutableNoopTask(
ProcessToolBox{
ClusterMetadata: s.clusterMetadata,
ClientBean: s.clientBean,
ShardController: s.shardController,
NamespaceCache: s.namespaceCache,
MetricsHandler: s.metricsHandler,
Logger: s.logger,
EagerNamespaceRefresher: s.eagerNamespaceRefresher,
DLQWriter: NoopDLQWriter{},
},
rand.Int63(),
time.Unix(0, rand.Int63()),
"sourceCluster",
ClusterShardKey{
ClusterID: int32(cluster.TestCurrentClusterInitialFailoverVersion),
ShardID: rand.Int31(),
},
)
}
func (s *executableNoopTaskSuite) TearDownTest() {
s.controller.Finish()
}
func (s *executableNoopTaskSuite) TestExecute() {
err := s.task.Execute()
s.NoError(err)
}
func (s *executableNoopTaskSuite) TestHandleErr() {
err := errors.New("OwO")
s.Equal(err, s.task.HandleErr(err))
err = serviceerror.NewUnavailable("")
s.Equal(err, s.task.HandleErr(err))
}
func (s *executableNoopTaskSuite) TestMarkPoisonPill() {
err := s.task.MarkPoisonPill()
s.NoError(err)
}