Files
tasks/common/persistence/sql/sqlplugin/tests/history_shard.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

217 lines
5.2 KiB
Go

package tests
import (
"math/rand"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"github.com/hanzoai/tasks/common/persistence/sql/sqlplugin"
"github.com/hanzoai/tasks/common/shuffle"
)
type (
historyShardSuite struct {
suite.Suite
*require.Assertions
store sqlplugin.DB
}
)
const (
testHistoryShardEncoding = "random encoding"
)
var (
testHistoryShardData = []byte("random history shard data")
)
func NewHistoryShardSuite(
t *testing.T,
store sqlplugin.DB,
) *historyShardSuite {
return &historyShardSuite{
Assertions: require.New(t),
store: store,
}
}
func (s *historyShardSuite) SetupSuite() {
}
func (s *historyShardSuite) TearDownSuite() {
}
func (s *historyShardSuite) SetupTest() {
s.Assertions = require.New(s.T())
}
func (s *historyShardSuite) TearDownTest() {
}
func (s *historyShardSuite) TestInsert_Success() {
shardID := rand.Int31()
rangeID := int64(1)
shard := s.newRandomShardRow(shardID, rangeID)
result, err := s.store.InsertIntoShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
}
func (s *historyShardSuite) TestInsert_Fail_Duplicate() {
shardID := rand.Int31()
rangeID := int64(1)
shard := s.newRandomShardRow(shardID, rangeID)
result, err := s.store.InsertIntoShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
shard = s.newRandomShardRow(shardID, rangeID)
_, err = s.store.InsertIntoShards(newExecutionContext(), &shard)
s.Error(err) // TODO persistence layer should do proper error translation
}
func (s *historyShardSuite) TestInsertSelect() {
shardID := rand.Int31()
rangeID := int64(1)
shard := s.newRandomShardRow(shardID, rangeID)
result, err := s.store.InsertIntoShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
filter := sqlplugin.ShardsFilter{
ShardID: shardID,
}
row, err := s.store.SelectFromShards(newExecutionContext(), filter)
s.NoError(err)
s.Equal(&shard, row)
}
func (s *historyShardSuite) TestInsertUpdate_Success() {
shardID := rand.Int31()
rangeID := int64(1)
shard := s.newRandomShardRow(shardID, rangeID)
rangeID += 100
result, err := s.store.InsertIntoShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
shard = s.newRandomShardRow(shardID, rangeID)
result, err = s.store.UpdateShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err = result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
}
func (s *historyShardSuite) TestUpdate_Fail() {
shardID := rand.Int31()
rangeID := int64(1)
shard := s.newRandomShardRow(shardID, rangeID)
result, err := s.store.UpdateShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(0, int(rowsAffected))
}
func (s *historyShardSuite) TestInsertUpdateSelect() {
shardID := rand.Int31()
rangeID := int64(1)
shard := s.newRandomShardRow(shardID, rangeID)
rangeID += 100
result, err := s.store.InsertIntoShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
shard = s.newRandomShardRow(shardID, rangeID)
result, err = s.store.UpdateShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err = result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
filter := sqlplugin.ShardsFilter{
ShardID: shardID,
}
row, err := s.store.SelectFromShards(newExecutionContext(), filter)
s.NoError(err)
s.Equal(&shard, row)
}
func (s *historyShardSuite) TestInsertReadLock() {
shardID := rand.Int31()
rangeID := int64(rand.Int31())
shard := s.newRandomShardRow(shardID, rangeID)
result, err := s.store.InsertIntoShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
tx, err := s.store.BeginTx(newExecutionContext())
s.NoError(err)
filter := sqlplugin.ShardsFilter{
ShardID: shardID,
}
shardRange, err := tx.ReadLockShards(newExecutionContext(), filter)
s.NoError(err)
s.Equal(rangeID, shardRange)
s.NoError(tx.Commit())
}
func (s *historyShardSuite) TestInsertWriteLock() {
shardID := rand.Int31()
rangeID := int64(rand.Int31())
shard := s.newRandomShardRow(shardID, rangeID)
result, err := s.store.InsertIntoShards(newExecutionContext(), &shard)
s.NoError(err)
rowsAffected, err := result.RowsAffected()
s.NoError(err)
s.Equal(1, int(rowsAffected))
tx, err := s.store.BeginTx(newExecutionContext())
s.NoError(err)
filter := sqlplugin.ShardsFilter{
ShardID: shardID,
}
shardRange, err := tx.WriteLockShards(newExecutionContext(), filter)
s.NoError(err)
s.Equal(rangeID, shardRange)
s.NoError(tx.Commit())
}
func (s *historyShardSuite) newRandomShardRow(
shardID int32,
rangeID int64,
) sqlplugin.ShardsRow {
return sqlplugin.ShardsRow{
ShardID: shardID,
RangeID: rangeID,
Data: shuffle.Bytes(testHistoryShardData),
DataEncoding: testHistoryShardEncoding,
}
}