go.temporal.io/server@v1.23.0/common/persistence/sql/sqlplugin/tests/history_execution_child_workflow.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  	historyExecutionChildWorkflowSuite struct {
    41  		suite.Suite
    42  		*require.Assertions
    43  
    44  		store sqlplugin.HistoryExecutionChildWorkflow
    45  	}
    46  )
    47  
    48  const (
    49  	testHistoryExecutionChildWorkflowEncoding = "random encoding"
    50  )
    51  
    52  var (
    53  	testHistoryExecutionChildWorkflowData = []byte("random history execution child workflow data")
    54  )
    55  
    56  func NewHistoryExecutionChildWorkflowSuite(
    57  	t *testing.T,
    58  	store sqlplugin.HistoryExecutionChildWorkflow,
    59  ) *historyExecutionChildWorkflowSuite {
    60  	return &historyExecutionChildWorkflowSuite{
    61  		Assertions: require.New(t),
    62  		store:      store,
    63  	}
    64  }
    65  
    66  func (s *historyExecutionChildWorkflowSuite) SetupSuite() {
    67  
    68  }
    69  
    70  func (s *historyExecutionChildWorkflowSuite) TearDownSuite() {
    71  
    72  }
    73  
    74  func (s *historyExecutionChildWorkflowSuite) SetupTest() {
    75  	s.Assertions = require.New(s.T())
    76  }
    77  
    78  func (s *historyExecutionChildWorkflowSuite) TearDownTest() {
    79  
    80  }
    81  
    82  func (s *historyExecutionChildWorkflowSuite) TestReplace_Single() {
    83  	shardID := rand.Int31()
    84  	namespaceID := primitives.NewUUID()
    85  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
    86  	runID := primitives.NewUUID()
    87  	initiatedID := rand.Int63()
    88  
    89  	childWorkflow := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, initiatedID)
    90  	result, err := s.store.ReplaceIntoChildExecutionInfoMaps(newExecutionContext(), []sqlplugin.ChildExecutionInfoMapsRow{childWorkflow})
    91  	s.NoError(err)
    92  	rowsAffected, err := result.RowsAffected()
    93  	s.NoError(err)
    94  	s.Equal(1, int(rowsAffected))
    95  }
    96  
    97  func (s *historyExecutionChildWorkflowSuite) TestReplace_Multiple() {
    98  	shardID := rand.Int31()
    99  	namespaceID := primitives.NewUUID()
   100  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   101  	runID := primitives.NewUUID()
   102  
   103  	childWorkflow1 := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, rand.Int63())
   104  	childWorkflow2 := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, rand.Int63())
   105  	result, err := s.store.ReplaceIntoChildExecutionInfoMaps(newExecutionContext(), []sqlplugin.ChildExecutionInfoMapsRow{childWorkflow1, childWorkflow2})
   106  	s.NoError(err)
   107  	rowsAffected, err := result.RowsAffected()
   108  	s.NoError(err)
   109  	s.Equal(2, int(rowsAffected))
   110  }
   111  
   112  func (s *historyExecutionChildWorkflowSuite) TestReplaceSelect_Single() {
   113  	shardID := rand.Int31()
   114  	namespaceID := primitives.NewUUID()
   115  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   116  	runID := primitives.NewUUID()
   117  	initiatedID := rand.Int63()
   118  
   119  	childWorkflow := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, initiatedID)
   120  	result, err := s.store.ReplaceIntoChildExecutionInfoMaps(newExecutionContext(), []sqlplugin.ChildExecutionInfoMapsRow{childWorkflow})
   121  	s.NoError(err)
   122  	rowsAffected, err := result.RowsAffected()
   123  	s.NoError(err)
   124  	s.Equal(1, int(rowsAffected))
   125  
   126  	selectFilter := sqlplugin.ChildExecutionInfoMapsAllFilter{
   127  		ShardID:     shardID,
   128  		NamespaceID: namespaceID,
   129  		WorkflowID:  workflowID,
   130  		RunID:       runID,
   131  	}
   132  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   133  	s.NoError(err)
   134  	rowMap := map[int64]sqlplugin.ChildExecutionInfoMapsRow{}
   135  	for _, childWorkflow := range rows {
   136  		rowMap[childWorkflow.InitiatedID] = childWorkflow
   137  	}
   138  	s.Equal(map[int64]sqlplugin.ChildExecutionInfoMapsRow{
   139  		childWorkflow.InitiatedID: childWorkflow,
   140  	}, rowMap)
   141  }
   142  
   143  func (s *historyExecutionChildWorkflowSuite) TestReplaceSelect_Multiple() {
   144  	numChildWorkflows := 20
   145  
   146  	shardID := rand.Int31()
   147  	namespaceID := primitives.NewUUID()
   148  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   149  	runID := primitives.NewUUID()
   150  
   151  	var childWorkflows []sqlplugin.ChildExecutionInfoMapsRow
   152  	for i := 0; i < numChildWorkflows; i++ {
   153  		childWorkflow := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, rand.Int63())
   154  		childWorkflows = append(childWorkflows, childWorkflow)
   155  	}
   156  	result, err := s.store.ReplaceIntoChildExecutionInfoMaps(newExecutionContext(), childWorkflows)
   157  	s.NoError(err)
   158  	rowsAffected, err := result.RowsAffected()
   159  	s.NoError(err)
   160  	s.Equal(numChildWorkflows, int(rowsAffected))
   161  
   162  	selectFilter := sqlplugin.ChildExecutionInfoMapsAllFilter{
   163  		ShardID:     shardID,
   164  		NamespaceID: namespaceID,
   165  		WorkflowID:  workflowID,
   166  		RunID:       runID,
   167  	}
   168  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   169  	s.NoError(err)
   170  	childWorkflowMap := map[int64]sqlplugin.ChildExecutionInfoMapsRow{}
   171  	for _, childWorkflow := range childWorkflows {
   172  		childWorkflowMap[childWorkflow.InitiatedID] = childWorkflow
   173  	}
   174  	rowMap := map[int64]sqlplugin.ChildExecutionInfoMapsRow{}
   175  	for _, childWorkflow := range rows {
   176  		rowMap[childWorkflow.InitiatedID] = childWorkflow
   177  	}
   178  	s.Equal(childWorkflowMap, rowMap)
   179  }
   180  
   181  func (s *historyExecutionChildWorkflowSuite) TestDeleteSelect_Single() {
   182  	shardID := rand.Int31()
   183  	namespaceID := primitives.NewUUID()
   184  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   185  	runID := primitives.NewUUID()
   186  	initiatedID := rand.Int63()
   187  
   188  	deleteFilter := sqlplugin.ChildExecutionInfoMapsFilter{
   189  		ShardID:      shardID,
   190  		NamespaceID:  namespaceID,
   191  		WorkflowID:   workflowID,
   192  		RunID:        runID,
   193  		InitiatedIDs: []int64{initiatedID},
   194  	}
   195  	result, err := s.store.DeleteFromChildExecutionInfoMaps(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.ChildExecutionInfoMapsAllFilter{
   202  		ShardID:     shardID,
   203  		NamespaceID: namespaceID,
   204  		WorkflowID:  workflowID,
   205  		RunID:       runID,
   206  	}
   207  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   208  	s.NoError(err)
   209  	s.Equal([]sqlplugin.ChildExecutionInfoMapsRow(nil), rows)
   210  }
   211  
   212  func (s *historyExecutionChildWorkflowSuite) TestDeleteSelect_Multiple() {
   213  	shardID := rand.Int31()
   214  	namespaceID := primitives.NewUUID()
   215  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   216  	runID := primitives.NewUUID()
   217  
   218  	deleteFilter := sqlplugin.ChildExecutionInfoMapsFilter{
   219  		ShardID:      shardID,
   220  		NamespaceID:  namespaceID,
   221  		WorkflowID:   workflowID,
   222  		RunID:        runID,
   223  		InitiatedIDs: []int64{rand.Int63(), rand.Int63()},
   224  	}
   225  	result, err := s.store.DeleteFromChildExecutionInfoMaps(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.ChildExecutionInfoMapsAllFilter{
   232  		ShardID:     shardID,
   233  		NamespaceID: namespaceID,
   234  		WorkflowID:  workflowID,
   235  		RunID:       runID,
   236  	}
   237  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   238  	s.NoError(err)
   239  	s.Equal([]sqlplugin.ChildExecutionInfoMapsRow(nil), rows)
   240  }
   241  
   242  func (s *historyExecutionChildWorkflowSuite) TestDeleteSelect_All() {
   243  	shardID := rand.Int31()
   244  	namespaceID := primitives.NewUUID()
   245  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   246  	runID := primitives.NewUUID()
   247  
   248  	deleteFilter := sqlplugin.ChildExecutionInfoMapsAllFilter{
   249  		ShardID:     shardID,
   250  		NamespaceID: namespaceID,
   251  		WorkflowID:  workflowID,
   252  		RunID:       runID,
   253  	}
   254  	result, err := s.store.DeleteAllFromChildExecutionInfoMaps(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.ChildExecutionInfoMapsAllFilter{
   261  		ShardID:     shardID,
   262  		NamespaceID: namespaceID,
   263  		WorkflowID:  workflowID,
   264  		RunID:       runID,
   265  	}
   266  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   267  	s.NoError(err)
   268  	s.Equal([]sqlplugin.ChildExecutionInfoMapsRow(nil), rows)
   269  }
   270  
   271  func (s *historyExecutionChildWorkflowSuite) TestReplaceDeleteSelect_Single() {
   272  	shardID := rand.Int31()
   273  	namespaceID := primitives.NewUUID()
   274  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   275  	runID := primitives.NewUUID()
   276  	initiatedID := rand.Int63()
   277  
   278  	childWorkflow := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, initiatedID)
   279  	result, err := s.store.ReplaceIntoChildExecutionInfoMaps(newExecutionContext(), []sqlplugin.ChildExecutionInfoMapsRow{childWorkflow})
   280  	s.NoError(err)
   281  	rowsAffected, err := result.RowsAffected()
   282  	s.NoError(err)
   283  	s.Equal(1, int(rowsAffected))
   284  
   285  	deleteFilter := sqlplugin.ChildExecutionInfoMapsFilter{
   286  		ShardID:      shardID,
   287  		NamespaceID:  namespaceID,
   288  		WorkflowID:   workflowID,
   289  		RunID:        runID,
   290  		InitiatedIDs: []int64{initiatedID},
   291  	}
   292  	result, err = s.store.DeleteFromChildExecutionInfoMaps(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.ChildExecutionInfoMapsAllFilter{
   299  		ShardID:     shardID,
   300  		NamespaceID: namespaceID,
   301  		WorkflowID:  workflowID,
   302  		RunID:       runID,
   303  	}
   304  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   305  	s.NoError(err)
   306  	s.Equal([]sqlplugin.ChildExecutionInfoMapsRow(nil), rows)
   307  }
   308  
   309  func (s *historyExecutionChildWorkflowSuite) TestReplaceDeleteSelect_Multiple() {
   310  	numChildWorkflows := 20
   311  
   312  	shardID := rand.Int31()
   313  	namespaceID := primitives.NewUUID()
   314  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   315  	runID := primitives.NewUUID()
   316  
   317  	var childWorkflows []sqlplugin.ChildExecutionInfoMapsRow
   318  	var childWorkflowInitiatedIDs []int64
   319  	for i := 0; i < numChildWorkflows; i++ {
   320  		childWorkflowInitiatedID := rand.Int63()
   321  		childWorkflow := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, childWorkflowInitiatedID)
   322  		childWorkflowInitiatedIDs = append(childWorkflowInitiatedIDs, childWorkflowInitiatedID)
   323  		childWorkflows = append(childWorkflows, childWorkflow)
   324  	}
   325  	result, err := s.store.ReplaceIntoChildExecutionInfoMaps(newExecutionContext(), childWorkflows)
   326  	s.NoError(err)
   327  	rowsAffected, err := result.RowsAffected()
   328  	s.NoError(err)
   329  	s.Equal(numChildWorkflows, int(rowsAffected))
   330  
   331  	deleteFilter := sqlplugin.ChildExecutionInfoMapsFilter{
   332  		ShardID:      shardID,
   333  		NamespaceID:  namespaceID,
   334  		WorkflowID:   workflowID,
   335  		RunID:        runID,
   336  		InitiatedIDs: childWorkflowInitiatedIDs,
   337  	}
   338  	result, err = s.store.DeleteFromChildExecutionInfoMaps(newExecutionContext(), deleteFilter)
   339  	s.NoError(err)
   340  	rowsAffected, err = result.RowsAffected()
   341  	s.NoError(err)
   342  	s.Equal(numChildWorkflows, int(rowsAffected))
   343  
   344  	selectFilter := sqlplugin.ChildExecutionInfoMapsAllFilter{
   345  		ShardID:     shardID,
   346  		NamespaceID: namespaceID,
   347  		WorkflowID:  workflowID,
   348  		RunID:       runID,
   349  	}
   350  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   351  	s.NoError(err)
   352  	s.Equal([]sqlplugin.ChildExecutionInfoMapsRow(nil), rows)
   353  }
   354  
   355  func (s *historyExecutionChildWorkflowSuite) TestReplaceDeleteSelect_All() {
   356  	numChildWorkflows := 20
   357  
   358  	shardID := rand.Int31()
   359  	namespaceID := primitives.NewUUID()
   360  	workflowID := shuffle.String(testHistoryExecutionWorkflowID)
   361  	runID := primitives.NewUUID()
   362  
   363  	var childWorkflows []sqlplugin.ChildExecutionInfoMapsRow
   364  	for i := 0; i < numChildWorkflows; i++ {
   365  		childWorkflow := s.newRandomExecutionChildWorkflowRow(shardID, namespaceID, workflowID, runID, rand.Int63())
   366  		childWorkflows = append(childWorkflows, childWorkflow)
   367  	}
   368  	result, err := s.store.ReplaceIntoChildExecutionInfoMaps(newExecutionContext(), childWorkflows)
   369  	s.NoError(err)
   370  	rowsAffected, err := result.RowsAffected()
   371  	s.NoError(err)
   372  	s.Equal(numChildWorkflows, int(rowsAffected))
   373  
   374  	deleteFilter := sqlplugin.ChildExecutionInfoMapsAllFilter{
   375  		ShardID:     shardID,
   376  		NamespaceID: namespaceID,
   377  		WorkflowID:  workflowID,
   378  		RunID:       runID,
   379  	}
   380  	result, err = s.store.DeleteAllFromChildExecutionInfoMaps(newExecutionContext(), deleteFilter)
   381  	s.NoError(err)
   382  	rowsAffected, err = result.RowsAffected()
   383  	s.NoError(err)
   384  	s.Equal(numChildWorkflows, int(rowsAffected))
   385  
   386  	selectFilter := sqlplugin.ChildExecutionInfoMapsAllFilter{
   387  		ShardID:     shardID,
   388  		NamespaceID: namespaceID,
   389  		WorkflowID:  workflowID,
   390  		RunID:       runID,
   391  	}
   392  	rows, err := s.store.SelectAllFromChildExecutionInfoMaps(newExecutionContext(), selectFilter)
   393  	s.NoError(err)
   394  	s.Equal([]sqlplugin.ChildExecutionInfoMapsRow(nil), rows)
   395  }
   396  
   397  func (s *historyExecutionChildWorkflowSuite) newRandomExecutionChildWorkflowRow(
   398  	shardID int32,
   399  	namespaceID primitives.UUID,
   400  	workflowID string,
   401  	runID primitives.UUID,
   402  	initiatedID int64,
   403  ) sqlplugin.ChildExecutionInfoMapsRow {
   404  	return sqlplugin.ChildExecutionInfoMapsRow{
   405  		ShardID:      shardID,
   406  		NamespaceID:  namespaceID,
   407  		WorkflowID:   workflowID,
   408  		RunID:        runID,
   409  		InitiatedID:  initiatedID,
   410  		Data:         shuffle.Bytes(testHistoryExecutionChildWorkflowData),
   411  		DataEncoding: testHistoryExecutionChildWorkflowEncoding,
   412  	}
   413  }