go.uber.org/cadence@v1.2.9/internal/internal_event_handlers_test.go

// Copyright (c) 2017 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

package internal

import (
	"encoding/json"
	"go.uber.org/cadence/internal/common"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"go.uber.org/zap/zaptest/observer"

	s "go.uber.org/cadence/.gen/go/shared"
)

func TestReplayAwareLogger(t *testing.T) {
	t.Parallel()
	core, observed := observer.New(zapcore.InfoLevel)
	logger := zap.New(core, zap.Development())

	isReplay, enableLoggingInReplay := false, false
	logger = logger.WithOptions(zap.WrapCore(wrapLogger(&isReplay, &enableLoggingInReplay)))

	logger.Info("normal info")

	isReplay = true
	logger.Info("replay info") // this log should be suppressed

	isReplay, enableLoggingInReplay = false, true
	logger.Info("normal2 info")

	isReplay = true
	logger.Info("replay2 info")

	var messages []string
	for _, log := range observed.AllUntimed() {
		messages = append(messages, log.Message)
	}
	assert.Len(t, messages, 3) // ensures "replay info" wasn't just misspelled
	assert.Contains(t, messages, "normal info")
	assert.NotContains(t, messages, "replay info")
	assert.Contains(t, messages, "normal2 info")
	assert.Contains(t, messages, "replay2 info")
}

func testDecodeValueHelper(t *testing.T, env *workflowEnvironmentImpl) {
	equals := func(a, b interface{}) bool {
		ao := a.(ActivityOptions)
		bo := b.(ActivityOptions)
		return ao.TaskList == bo.TaskList
	}
	value := ActivityOptions{TaskList: "test-tasklist"}
	blob := env.encodeValue(value)
	isEqual := env.isEqualValue(value, blob, equals)
	require.True(t, isEqual)

	value.TaskList = "value-changed"
	isEqual = env.isEqualValue(value, blob, equals)
	require.False(t, isEqual)
}

func TestDecodedValue(t *testing.T) {
	t.Parallel()
	env := &workflowEnvironmentImpl{
		dataConverter: getDefaultDataConverter(),
	}
	testDecodeValueHelper(t, env)
}

func TestDecodedValue_WithDataConverter(t *testing.T) {
	t.Parallel()
	env := &workflowEnvironmentImpl{
		dataConverter: newTestDataConverter(),
	}
	testDecodeValueHelper(t, env)
}

func Test_DecodedValuePtr(t *testing.T) {
	t.Parallel()
	env := &workflowEnvironmentImpl{
		dataConverter: getDefaultDataConverter(),
	}
	equals := func(a, b interface{}) bool {
		ao := a.(*ActivityOptions)
		bo := b.(*ActivityOptions)
		return ao.TaskList == bo.TaskList
	}
	value := &ActivityOptions{TaskList: "test-tasklist"}
	blob := env.encodeValue(value)
	isEqual := env.isEqualValue(value, blob, equals)
	require.True(t, isEqual)

	value.TaskList = "value-changed"
	isEqual = env.isEqualValue(value, blob, equals)
	require.False(t, isEqual)
}

func Test_DecodedValueNil(t *testing.T) {
	t.Parallel()
	env := &workflowEnvironmentImpl{
		dataConverter: getDefaultDataConverter(),
	}
	equals := func(a, b interface{}) bool {
		return a == nil && b == nil
	}
	// newValue is nil, old value is nil
	var value interface{}
	blob := env.encodeValue(value)
	isEqual := env.isEqualValue(value, blob, equals)
	require.True(t, isEqual)

	// newValue is nil, oldValue is not nil
	blob = env.encodeValue("any-non-nil-value")
	isEqual = env.isEqualValue(value, blob, equals)
	require.False(t, isEqual)

	// newValue is not nil, oldValue is nil
	blob = env.encodeValue(nil)
	isEqual = env.isEqualValue("non-nil-value", blob, equals)
	require.False(t, isEqual)
}

func Test_ValidateAndSerializeSearchAttributes(t *testing.T) {
	t.Parallel()
	_, err := validateAndSerializeSearchAttributes(nil)
	require.EqualError(t, err, "search attributes is empty")

	attr := map[string]interface{}{
		"JustKey": make(chan int),
	}
	_, err = validateAndSerializeSearchAttributes(attr)
	require.EqualError(t, err, "encode search attribute [JustKey] error: json: unsupported type: chan int")

	attr = map[string]interface{}{
		"key": 1,
	}
	searchAttr, err := validateAndSerializeSearchAttributes(attr)
	require.NoError(t, err)
	require.Equal(t, 1, len(searchAttr.IndexedFields))
	var resp int
	json.Unmarshal(searchAttr.IndexedFields["key"], &resp)
	require.Equal(t, 1, resp)
}

func Test_UpsertSearchAttributes(t *testing.T) {
	t.Parallel()
	env := &workflowEnvironmentImpl{
		decisionsHelper: newDecisionsHelper(),
		workflowInfo:    GetWorkflowInfo(createRootTestContext(t)),
	}
	err := env.UpsertSearchAttributes(nil)
	require.Error(t, err)

	err = env.UpsertSearchAttributes(map[string]interface{}{
		CadenceChangeVersion: []string{"change2-1", "change1-1"}},
	)
	require.NoError(t, err)
	_, ok := env.decisionsHelper.decisions[makeDecisionID(decisionTypeUpsertSearchAttributes, "change2-1")]
	require.True(t, ok)
	require.Equal(t, int32(0), env.counterID)

	err = env.UpsertSearchAttributes(map[string]interface{}{"key": 1})
	require.NoError(t, err)
	require.Equal(t, int32(1), env.counterID)
}

func Test_MergeSearchAttributes(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name     string
		current  *s.SearchAttributes
		upsert   *s.SearchAttributes
		expected *s.SearchAttributes
	}{
		{
			name:     "currentIsNil",
			current:  nil,
			upsert:   &s.SearchAttributes{},
			expected: nil,
		},
		{
			name:     "currentIsEmpty",
			current:  &s.SearchAttributes{IndexedFields: make(map[string][]byte)},
			upsert:   &s.SearchAttributes{},
			expected: nil,
		},
		{
			name: "normalMerge",
			current: &s.SearchAttributes{
				IndexedFields: map[string][]byte{
					"CustomIntField":     []byte(`1`),
					"CustomKeywordField": []byte(`keyword`),
				},
			},
			upsert: &s.SearchAttributes{
				IndexedFields: map[string][]byte{
					"CustomIntField":  []byte(`2`),
					"CustomBoolField": []byte(`true`),
				},
			},
			expected: &s.SearchAttributes{
				IndexedFields: map[string][]byte{
					"CustomIntField":     []byte(`2`),
					"CustomKeywordField": []byte(`keyword`),
					"CustomBoolField":    []byte(`true`),
				},
			},
		},
	}

	for _, test := range tests {
		test := test
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()
			result := mergeSearchAttributes(test.current, test.upsert)
			require.Equal(t, test.expected, result)
		})
	}
}

func Test_GetChangeVersion(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name     string
		changeID string
		version  Version
		expected string
	}{
		{
			name:     "default",
			changeID: "cid",
			version:  DefaultVersion,
			expected: "cid--1",
		},
		{
			name:     "normal_case",
			changeID: "cid",
			version:  1,
			expected: "cid-1",
		},
	}
	for _, test := range tests {
		test := test
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()
			result := getChangeVersion(test.changeID, test.version)
			require.Equal(t, test.expected, result)
		})
	}
}

func Test_GetChangeVersions(t *testing.T) {
	t.Parallel()
	tests := []struct {
		name                   string
		changeID               string
		version                Version
		existingChangeVersions map[string]Version
		expected               []string
	}{
		{
			name:                   "single_change_id",
			changeID:               "cid",
			version:                1,
			existingChangeVersions: map[string]Version{},
			expected:               []string{"cid-1"},
		},
		{
			name:     "multi_change_ids",
			changeID: "cid2",
			version:  1,
			existingChangeVersions: map[string]Version{
				"cid": 1,
			},
			expected: []string{"cid2-1", "cid-1"},
		},
	}
	for _, test := range tests {
		test := test
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()
			result := getChangeVersions(test.changeID, test.version, test.existingChangeVersions)
			require.Equal(t, test.expected, result)
		})
	}
}

func Test_CreateSearchAttributesForChangeVersion(t *testing.T) {
	t.Parallel()
	result := createSearchAttributesForChangeVersion("cid", 1, map[string]Version{})
	val, ok := result["CadenceChangeVersion"]
	require.True(t, ok, "Remember to update related key on server side")
	require.Equal(t, []string{"cid-1"}, val)
}

func TestHistoryEstimationforSmallEvents(t *testing.T) {
	taskList := "tasklist"
	testEvents := []*s.HistoryEvent{
		createTestEventWorkflowExecutionStarted(1, &s.WorkflowExecutionStartedEventAttributes{TaskList: &s.TaskList{Name: &taskList}}),
		createTestEventDecisionTaskScheduled(2, &s.DecisionTaskScheduledEventAttributes{TaskList: &s.TaskList{Name: &taskList}}),
		createTestEventDecisionTaskStarted(3),
		{
			EventId:   common.Int64Ptr(4),
			EventType: common.EventTypePtr(s.EventTypeDecisionTaskFailed),
		},
		{
			EventId:   common.Int64Ptr(5),
			EventType: common.EventTypePtr(s.EventTypeWorkflowExecutionSignaled),
		},
		createTestEventDecisionTaskScheduled(6, &s.DecisionTaskScheduledEventAttributes{TaskList: &s.TaskList{Name: &taskList}}),
		createTestEventDecisionTaskStarted(7),
	}
	core, _ := observer.New(zapcore.InfoLevel)
	logger := zap.New(core, zap.Development())
	w := workflowExecutionEventHandlerImpl{
		workflowEnvironmentImpl: &workflowEnvironmentImpl{logger: logger},
	}

	w.logger = logger
	historySizeSum := 0
	for _, event := range testEvents {
		sum := estimateHistorySize(logger, event)
		historySizeSum += sum
	}
	trueSize := len(testEvents) * historySizeEstimationBuffer

	assert.Equal(t, trueSize, historySizeSum)
}

func TestHistoryEstimationforPackedEvents(t *testing.T) {
	// create an array of bytes for testing
	var byteArray []byte
	byteArray = append(byteArray, 100)
	taskList := "tasklist"
	testEvents := []*s.HistoryEvent{
		createTestEventWorkflowExecutionStarted(1, &s.WorkflowExecutionStartedEventAttributes{
			TaskList:                &s.TaskList{Name: &taskList},
			Input:                   byteArray,
			ContinuedFailureDetails: byteArray}),
		createTestEventWorkflowExecutionStarted(2, &s.WorkflowExecutionStartedEventAttributes{
			TaskList:                &s.TaskList{Name: &taskList},
			Input:                   byteArray,
			ContinuedFailureDetails: byteArray}),
		createTestEventWorkflowExecutionStarted(3, &s.WorkflowExecutionStartedEventAttributes{
			TaskList:                &s.TaskList{Name: &taskList},
			Input:                   byteArray,
			ContinuedFailureDetails: byteArray}),
	}
	core, _ := observer.New(zapcore.InfoLevel)
	logger := zap.New(core, zap.Development())
	w := workflowExecutionEventHandlerImpl{
		workflowEnvironmentImpl: &workflowEnvironmentImpl{logger: logger},
	}

	w.logger = logger
	historySizeSum := 0
	for _, event := range testEvents {
		sum := estimateHistorySize(logger, event)
		historySizeSum += sum
	}
	trueSize := len(testEvents)*historySizeEstimationBuffer + len(byteArray)*2*len(testEvents)
	assert.Equal(t, trueSize, historySizeSum)
}

func TestProcessQuery_KnownQueryTypes(t *testing.T) {
	rootCtx := setWorkflowEnvOptionsIfNotExist(Background())
	eo := getWorkflowEnvOptions(rootCtx)
	eo.queryHandlers["a"] = nil

	weh := &workflowExecutionEventHandlerImpl{
		workflowEnvironmentImpl: &workflowEnvironmentImpl{
			dataConverter: DefaultDataConverter,
		},
		workflowDefinition: &syncWorkflowDefinition{
			rootCtx: rootCtx,
		},
	}

	result, err := weh.ProcessQuery(QueryTypeQueryTypes, nil)
	assert.NoError(t, err)
	assert.Equal(t, "[\"__open_sessions\",\"__query_types\",\"__stack_trace\",\"a\"]\n", string(result))
}