go.temporal.io/server@v1.23.0/common/persistence/sql/sqlplugin/tests/history_execution_activity.go (about)

     1  // The MIT License
     2  //
     3  // Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
     4  //
     5  // Copyright (c) 2020 Uber Technologies, Inc.
     6  //
     7  // Permission is hereby granted, free of charge, to any person obtaining a copy
     8  // of this software and associated documentation files (the "Software"), to deal
     9  // in the Software without restriction, including without limitation the rights
    10  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    11  // copies of the Software, and to permit persons to whom the Software is
    12  // furnished to do so, subject to the following conditions:
    13  //
    14  // The above copyright notice and this permission notice shall be included in
    15  // all copies or substantial portions of the Software.
    16  //
    17  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    18  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    19  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    20  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    21  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    22  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    23  // THE SOFTWARE.
    24  
    25  package tests
    26  
    27  import (
    28  	"math/rand"
    29  	"testing"
    30  
    31  	"github.com/stretchr/testify/require"
    32  	"github.com/stretchr/testify/suite"
    33  
    34  	"go.temporal.io/server/common/persistence/sql/sqlplugin"
    35  	"go.temporal.io/server/common/primitives"
    36  	"go.temporal.io/server/common/shuffle"
    37  )
    38  
    39  type (
    40  	historyExecutionActivitySuite struct {
    41  		suite.Suite
    42  		*require.Assertions
    43  
    44  		store sqlplugin.HistoryExecutionActivity
    45  	}
    46  )
    47  
    48  const (
    49  	testHistoryExecutionActivityEncoding = "random encoding"
    50  )
    51  
    52  var (
    53  	testHistoryExecutionActivityData = []byte("random history execution activity data")
    54  )
    55  
    56  func NewHistoryExecutionActivitySuite(
    57  	t *testing.T,
    58  	store sqlplugin.HistoryExecutionActivity,
    59  ) *historyExecutionActivitySuite {
    60  	return &historyExecutionActivitySuite{
    61  		Assertions: require.New(t),
    62  		store:      store,
    63  	}
    64  }
    65  
    66  func (s *historyExecutionActivitySuite) SetupSuite() {
    67  
    68  }
    69  
    70  func (s *historyExecutionActivitySuite) TearDownSuite() {
    71  
    72  }
    73  
    74  func (s *historyExecutionActivitySuite) SetupTest() {
    75  	s.Assertions = require.New(s.T())
    76  }
    77  
    78  func (s *historyExecutionActivitySuite) TearDownTest() {
    79  
    80  }
    81  
    82  func (s *historyExecutionActivitySuite) TestReplace_Single() {
    83  	shardID := rand.Int31()
    84  	namespaceID := primitives.NewUUID()
    85  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
    86  	runID := primitives.NewUUID()
    87  	scheduledEventID := rand.Int63()
    88  
    89  	activity := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, scheduledEventID)
    90  	result, err := s.store.ReplaceIntoActivityInfoMaps(newExecutionContext(), []sqlplugin.ActivityInfoMapsRow{activity})
    91  	s.NoError(err)
    92  	rowsAffected, err := result.RowsAffected()
    93  	s.NoError(err)
    94  	s.Equal(1, int(rowsAffected))
    95  }
    96  
    97  func (s *historyExecutionActivitySuite) TestReplace_Multiple() {
    98  	shardID := rand.Int31()
    99  	namespaceID := primitives.NewUUID()
   100  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   101  	runID := primitives.NewUUID()
   102  
   103  	activity1 := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, rand.Int63())
   104  	activity2 := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, rand.Int63())
   105  	result, err := s.store.ReplaceIntoActivityInfoMaps(newExecutionContext(), []sqlplugin.ActivityInfoMapsRow{activity1, activity2})
   106  	s.NoError(err)
   107  	rowsAffected, err := result.RowsAffected()
   108  	s.NoError(err)
   109  	s.Equal(2, int(rowsAffected))
   110  }
   111  
   112  func (s *historyExecutionActivitySuite) TestReplaceSelect_Single() {
   113  	shardID := rand.Int31()
   114  	namespaceID := primitives.NewUUID()
   115  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   116  	runID := primitives.NewUUID()
   117  	scheduledEventID := rand.Int63()
   118  
   119  	activity := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, scheduledEventID)
   120  	result, err := s.store.ReplaceIntoActivityInfoMaps(newExecutionContext(), []sqlplugin.ActivityInfoMapsRow{activity})
   121  	s.NoError(err)
   122  	rowsAffected, err := result.RowsAffected()
   123  	s.NoError(err)
   124  	s.Equal(1, int(rowsAffected))
   125  
   126  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   127  		ShardID:     shardID,
   128  		NamespaceID: namespaceID,
   129  		WorkflowID:  workflowID,
   130  		RunID:       runID,
   131  	}
   132  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   133  	s.NoError(err)
   134  	rowMap := map[int64]sqlplugin.ActivityInfoMapsRow{}
   135  	for _, activity := range rows {
   136  		rowMap[activity.ScheduleID] = activity
   137  	}
   138  	s.Equal(map[int64]sqlplugin.ActivityInfoMapsRow{
   139  		activity.ScheduleID: activity,
   140  	}, rowMap)
   141  }
   142  
   143  func (s *historyExecutionActivitySuite) TestReplaceSelect_Multiple() {
   144  	numActivities := 20
   145  
   146  	shardID := rand.Int31()
   147  	namespaceID := primitives.NewUUID()
   148  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   149  	runID := primitives.NewUUID()
   150  
   151  	var activities []sqlplugin.ActivityInfoMapsRow
   152  	for i := 0; i < numActivities; i++ {
   153  		activity := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, rand.Int63())
   154  		activities = append(activities, activity)
   155  	}
   156  	result, err := s.store.ReplaceIntoActivityInfoMaps(newExecutionContext(), activities)
   157  	s.NoError(err)
   158  	rowsAffected, err := result.RowsAffected()
   159  	s.NoError(err)
   160  	s.Equal(numActivities, int(rowsAffected))
   161  
   162  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   163  		ShardID:     shardID,
   164  		NamespaceID: namespaceID,
   165  		WorkflowID:  workflowID,
   166  		RunID:       runID,
   167  	}
   168  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   169  	s.NoError(err)
   170  	activityMap := map[int64]sqlplugin.ActivityInfoMapsRow{}
   171  	for _, activity := range activities {
   172  		activityMap[activity.ScheduleID] = activity
   173  	}
   174  	rowMap := map[int64]sqlplugin.ActivityInfoMapsRow{}
   175  	for _, activity := range rows {
   176  		rowMap[activity.ScheduleID] = activity
   177  	}
   178  	s.Equal(activityMap, rowMap)
   179  }
   180  
   181  func (s *historyExecutionActivitySuite) TestDeleteSelect_Single() {
   182  	shardID := rand.Int31()
   183  	namespaceID := primitives.NewUUID()
   184  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   185  	runID := primitives.NewUUID()
   186  	scheduledEventID := rand.Int63()
   187  
   188  	deleteFilter := sqlplugin.ActivityInfoMapsFilter{
   189  		ShardID:     shardID,
   190  		NamespaceID: namespaceID,
   191  		WorkflowID:  workflowID,
   192  		RunID:       runID,
   193  		ScheduleIDs: []int64{scheduledEventID},
   194  	}
   195  	result, err := s.store.DeleteFromActivityInfoMaps(newExecutionContext(), deleteFilter)
   196  	s.NoError(err)
   197  	rowsAffected, err := result.RowsAffected()
   198  	s.NoError(err)
   199  	s.Equal(0, int(rowsAffected))
   200  
   201  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   202  		ShardID:     shardID,
   203  		NamespaceID: namespaceID,
   204  		WorkflowID:  workflowID,
   205  		RunID:       runID,
   206  	}
   207  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   208  	s.NoError(err)
   209  	s.Equal([]sqlplugin.ActivityInfoMapsRow(nil), rows)
   210  }
   211  
   212  func (s *historyExecutionActivitySuite) TestDeleteSelect_Multiple() {
   213  	shardID := rand.Int31()
   214  	namespaceID := primitives.NewUUID()
   215  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   216  	runID := primitives.NewUUID()
   217  
   218  	deleteFilter := sqlplugin.ActivityInfoMapsFilter{
   219  		ShardID:     shardID,
   220  		NamespaceID: namespaceID,
   221  		WorkflowID:  workflowID,
   222  		RunID:       runID,
   223  		ScheduleIDs: []int64{rand.Int63(), rand.Int63()},
   224  	}
   225  	result, err := s.store.DeleteFromActivityInfoMaps(newExecutionContext(), deleteFilter)
   226  	s.NoError(err)
   227  	rowsAffected, err := result.RowsAffected()
   228  	s.NoError(err)
   229  	s.Equal(0, int(rowsAffected))
   230  
   231  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   232  		ShardID:     shardID,
   233  		NamespaceID: namespaceID,
   234  		WorkflowID:  workflowID,
   235  		RunID:       runID,
   236  	}
   237  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   238  	s.NoError(err)
   239  	s.Equal([]sqlplugin.ActivityInfoMapsRow(nil), rows)
   240  }
   241  
   242  func (s *historyExecutionActivitySuite) TestDeleteSelect_All() {
   243  	shardID := rand.Int31()
   244  	namespaceID := primitives.NewUUID()
   245  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   246  	runID := primitives.NewUUID()
   247  
   248  	deleteFilter := sqlplugin.ActivityInfoMapsAllFilter{
   249  		ShardID:     shardID,
   250  		NamespaceID: namespaceID,
   251  		WorkflowID:  workflowID,
   252  		RunID:       runID,
   253  	}
   254  	result, err := s.store.DeleteAllFromActivityInfoMaps(newExecutionContext(), deleteFilter)
   255  	s.NoError(err)
   256  	rowsAffected, err := result.RowsAffected()
   257  	s.NoError(err)
   258  	s.Equal(0, int(rowsAffected))
   259  
   260  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   261  		ShardID:     shardID,
   262  		NamespaceID: namespaceID,
   263  		WorkflowID:  workflowID,
   264  		RunID:       runID,
   265  	}
   266  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   267  	s.NoError(err)
   268  	s.Equal([]sqlplugin.ActivityInfoMapsRow(nil), rows)
   269  }
   270  
   271  func (s *historyExecutionActivitySuite) TestReplaceDeleteSelect_Single() {
   272  	shardID := rand.Int31()
   273  	namespaceID := primitives.NewUUID()
   274  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   275  	runID := primitives.NewUUID()
   276  	scheduledEventID := rand.Int63()
   277  
   278  	activity := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, scheduledEventID)
   279  	result, err := s.store.ReplaceIntoActivityInfoMaps(newExecutionContext(), []sqlplugin.ActivityInfoMapsRow{activity})
   280  	s.NoError(err)
   281  	rowsAffected, err := result.RowsAffected()
   282  	s.NoError(err)
   283  	s.Equal(1, int(rowsAffected))
   284  
   285  	deleteFilter := sqlplugin.ActivityInfoMapsFilter{
   286  		ShardID:     shardID,
   287  		NamespaceID: namespaceID,
   288  		WorkflowID:  workflowID,
   289  		RunID:       runID,
   290  		ScheduleIDs: []int64{scheduledEventID},
   291  	}
   292  	result, err = s.store.DeleteFromActivityInfoMaps(newExecutionContext(), deleteFilter)
   293  	s.NoError(err)
   294  	rowsAffected, err = result.RowsAffected()
   295  	s.NoError(err)
   296  	s.Equal(1, int(rowsAffected))
   297  
   298  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   299  		ShardID:     shardID,
   300  		NamespaceID: namespaceID,
   301  		WorkflowID:  workflowID,
   302  		RunID:       runID,
   303  	}
   304  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   305  	s.NoError(err)
   306  	s.Equal([]sqlplugin.ActivityInfoMapsRow(nil), rows)
   307  }
   308  
   309  func (s *historyExecutionActivitySuite) TestReplaceDeleteSelect_Multiple() {
   310  	numActivities := 20
   311  
   312  	shardID := rand.Int31()
   313  	namespaceID := primitives.NewUUID()
   314  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   315  	runID := primitives.NewUUID()
   316  
   317  	var activities []sqlplugin.ActivityInfoMapsRow
   318  	var activityScheduledEventIDs []int64
   319  	for i := 0; i < numActivities; i++ {
   320  		activityScheduledEventID := rand.Int63()
   321  		activity := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, activityScheduledEventID)
   322  		activityScheduledEventIDs = append(activityScheduledEventIDs, activityScheduledEventID)
   323  		activities = append(activities, activity)
   324  	}
   325  	result, err := s.store.ReplaceIntoActivityInfoMaps(newExecutionContext(), activities)
   326  	s.NoError(err)
   327  	rowsAffected, err := result.RowsAffected()
   328  	s.NoError(err)
   329  	s.Equal(numActivities, int(rowsAffected))
   330  
   331  	deleteFilter := sqlplugin.ActivityInfoMapsFilter{
   332  		ShardID:     shardID,
   333  		NamespaceID: namespaceID,
   334  		WorkflowID:  workflowID,
   335  		RunID:       runID,
   336  		ScheduleIDs: activityScheduledEventIDs,
   337  	}
   338  	result, err = s.store.DeleteFromActivityInfoMaps(newExecutionContext(), deleteFilter)
   339  	s.NoError(err)
   340  	rowsAffected, err = result.RowsAffected()
   341  	s.NoError(err)
   342  	s.Equal(numActivities, int(rowsAffected))
   343  
   344  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   345  		ShardID:     shardID,
   346  		NamespaceID: namespaceID,
   347  		WorkflowID:  workflowID,
   348  		RunID:       runID,
   349  	}
   350  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   351  	s.NoError(err)
   352  	s.Equal([]sqlplugin.ActivityInfoMapsRow(nil), rows)
   353  }
   354  
   355  func (s *historyExecutionActivitySuite) TestReplaceDeleteSelect_All() {
   356  	numActivities := 20
   357  
   358  	shardID := rand.Int31()
   359  	namespaceID := primitives.NewUUID()
   360  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   361  	runID := primitives.NewUUID()
   362  
   363  	var activities []sqlplugin.ActivityInfoMapsRow
   364  	for i := 0; i < numActivities; i++ {
   365  		activityScheduledEventID := rand.Int63()
   366  		activity := s.newRandomExecutionActivityRow(shardID, namespaceID, workflowID, runID, activityScheduledEventID)
   367  		activities = append(activities, activity)
   368  	}
   369  	result, err := s.store.ReplaceIntoActivityInfoMaps(newExecutionContext(), activities)
   370  	s.NoError(err)
   371  	rowsAffected, err := result.RowsAffected()
   372  	s.NoError(err)
   373  	s.Equal(numActivities, int(rowsAffected))
   374  
   375  	deleteFilter := sqlplugin.ActivityInfoMapsAllFilter{
   376  		ShardID:     shardID,
   377  		NamespaceID: namespaceID,
   378  		WorkflowID:  workflowID,
   379  		RunID:       runID,
   380  	}
   381  	result, err = s.store.DeleteAllFromActivityInfoMaps(newExecutionContext(), deleteFilter)
   382  	s.NoError(err)
   383  	rowsAffected, err = result.RowsAffected()
   384  	s.NoError(err)
   385  	s.Equal(numActivities, int(rowsAffected))
   386  
   387  	selectFilter := sqlplugin.ActivityInfoMapsAllFilter{
   388  		ShardID:     shardID,
   389  		NamespaceID: namespaceID,
   390  		WorkflowID:  workflowID,
   391  		RunID:       runID,
   392  	}
   393  	rows, err := s.store.SelectAllFromActivityInfoMaps(newExecutionContext(), selectFilter)
   394  	s.NoError(err)
   395  	s.Equal([]sqlplugin.ActivityInfoMapsRow(nil), rows)
   396  }
   397  
   398  func (s *historyExecutionActivitySuite) newRandomExecutionActivityRow(
   399  	shardID int32,
   400  	namespaceID primitives.UUID,
   401  	workflowID string,
   402  	runID primitives.UUID,
   403  	scheduledEventID int64,
   404  ) sqlplugin.ActivityInfoMapsRow {
   405  	return sqlplugin.ActivityInfoMapsRow{
   406  		ShardID:      shardID,
   407  		NamespaceID:  namespaceID,
   408  		WorkflowID:   workflowID,
   409  		RunID:        runID,
   410  		ScheduleID:   scheduledEventID,
   411  		Data:         shuffle.Bytes(testHistoryExecutionActivityData),
   412  		DataEncoding: testHistoryExecutionActivityEncoding,
   413  	}
   414  }