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