1878 lines
56 KiB
Go
1878 lines
56 KiB
Go
package automation
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/gochat/gochat/internal/model"
|
|
)
|
|
|
|
// ===========================
|
|
// NormalizeFilterOperator tests
|
|
// ===========================
|
|
|
|
func TestNormalizeFilterOperator_EqualTo_Cov7(t *testing.T) {
|
|
assert.Equal(t, "equal", NormalizeFilterOperator("equal_to"))
|
|
}
|
|
|
|
func TestNormalizeFilterOperator_NotEqualTo_Cov7(t *testing.T) {
|
|
assert.Equal(t, "not_equal", NormalizeFilterOperator("not_equal_to"))
|
|
}
|
|
|
|
func TestNormalizeFilterOperator_PassThrough_Cov7(t *testing.T) {
|
|
assert.Equal(t, "contains", NormalizeFilterOperator("contains"))
|
|
}
|
|
|
|
func TestNormalizeFilterOperator_Empty_Cov7(t *testing.T) {
|
|
assert.Equal(t, "", NormalizeFilterOperator(""))
|
|
}
|
|
|
|
func TestNormalizeFilterOperator_Unknown_Cov7(t *testing.T) {
|
|
assert.Equal(t, "custom_op", NormalizeFilterOperator("custom_op"))
|
|
}
|
|
|
|
// ===========================
|
|
// ChatwootFilterOperator tests
|
|
// ===========================
|
|
|
|
func TestChatwootFilterOperator_Equal_Cov7(t *testing.T) {
|
|
assert.Equal(t, "equal_to", ChatwootFilterOperator("equal"))
|
|
}
|
|
|
|
func TestChatwootFilterOperator_NotEqual_Cov7(t *testing.T) {
|
|
assert.Equal(t, "not_equal_to", ChatwootFilterOperator("not_equal"))
|
|
}
|
|
|
|
func TestChatwootFilterOperator_PassThrough_Cov7(t *testing.T) {
|
|
assert.Equal(t, "contains", ChatwootFilterOperator("contains"))
|
|
}
|
|
|
|
func TestChatwootFilterOperator_Empty_Cov7(t *testing.T) {
|
|
assert.Equal(t, "", ChatwootFilterOperator(""))
|
|
}
|
|
|
|
func TestChatwootFilterOperator_Unknown_Cov7(t *testing.T) {
|
|
assert.Equal(t, "custom", ChatwootFilterOperator("custom"))
|
|
}
|
|
|
|
// ===========================
|
|
// NormalizeConditions tests
|
|
// ===========================
|
|
|
|
func TestNormalizeConditions_Empty_Cov7(t *testing.T) {
|
|
result := NormalizeConditions(Conditions{})
|
|
assert.Empty(t, result)
|
|
}
|
|
|
|
func TestNormalizeConditions_AttributeKeyOnly_Cov7(t *testing.T) {
|
|
conds := Conditions{{AttributeKey: "status", FilterOperator: "equal_to", Values: []string{"open"}}}
|
|
result := NormalizeConditions(conds)
|
|
assert.Equal(t, "status", result[0].Attribute)
|
|
assert.Equal(t, "equal", result[0].FilterOperator)
|
|
}
|
|
|
|
func TestNormalizeConditions_AttributeOnly_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "equal", Values: []string{"open"}}}
|
|
result := NormalizeConditions(conds)
|
|
assert.Equal(t, "status", result[0].AttributeKey)
|
|
}
|
|
|
|
func TestNormalizeConditions_BothSet_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", AttributeKey: "status", FilterOperator: "equal_to", Values: []string{"open"}}}
|
|
result := NormalizeConditions(conds)
|
|
assert.Equal(t, "status", result[0].Attribute)
|
|
assert.Equal(t, "equal", result[0].FilterOperator)
|
|
}
|
|
|
|
func TestNormalizeConditions_Multiple_Cov7(t *testing.T) {
|
|
conds := Conditions{
|
|
{AttributeKey: "status", FilterOperator: "equal_to", Values: []string{"open"}},
|
|
{Attribute: "priority", FilterOperator: "not_equal_to", Values: []string{"low"}},
|
|
}
|
|
result := NormalizeConditions(conds)
|
|
assert.Len(t, result, 2)
|
|
assert.Equal(t, "equal", result[0].FilterOperator)
|
|
assert.Equal(t, "not_equal", result[1].FilterOperator)
|
|
}
|
|
|
|
// ===========================
|
|
// ValidateConditions tests
|
|
// ===========================
|
|
|
|
func TestValidateConditions_Empty_Cov7(t *testing.T) {
|
|
err := ValidateConditions(Conditions{})
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_Valid_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "equal", Values: []string{"open"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_InvalidAttribute_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "invalid_attr", FilterOperator: "equal", Values: []string{"open"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid attribute")
|
|
}
|
|
|
|
func TestValidateConditions_InvalidOperator_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "invalid_op", Values: []string{"open"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid filter_operator")
|
|
}
|
|
|
|
func TestValidateConditions_InvalidQueryOperator_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "equal", Values: []string{"open"}, QueryOperator: "invalid"}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid query_operator")
|
|
}
|
|
|
|
func TestValidateConditions_NoValues_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "equal", Values: nil}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "requires at least one value")
|
|
}
|
|
|
|
func TestValidateConditions_IsPresentNoValues_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "is_present", Values: nil}}
|
|
err := ValidateConditions(conds)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_IsNotPresentNoValues_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "is_not_present", Values: nil}}
|
|
err := ValidateConditions(conds)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_AttributeChangedNoValues_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "attribute_changed", Values: nil}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "attribute_changed requires")
|
|
}
|
|
|
|
func TestValidateConditions_AttributeChangedWithValues_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "status", FilterOperator: "attribute_changed", Values: []string{"resolved"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_MessageTypeWrongOp_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "message_type", FilterOperator: "contains", Values: []string{"incoming"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "does not support")
|
|
}
|
|
|
|
func TestValidateConditions_PrivateNoteWrongOp_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "private_note", FilterOperator: "contains", Values: []string{"true"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_ContentWrongOp_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "content", FilterOperator: "is_present", Values: nil}}
|
|
err := ValidateConditions(conds)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_ContentEqual_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "content", FilterOperator: "equal", Values: []string{"hello"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateConditions_ContentContains_Cov7(t *testing.T) {
|
|
conds := Conditions{{Attribute: "content", FilterOperator: "contains", Values: []string{"hello"}}}
|
|
err := ValidateConditions(conds)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
// ===========================
|
|
// ValidateActions tests
|
|
// ===========================
|
|
|
|
func TestValidateActions_Empty_Cov7(t *testing.T) {
|
|
err := ValidateActions(Actions{})
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateActions_Valid_Cov7(t *testing.T) {
|
|
actions := Actions{{ActionName: "send_message", ActionParams: map[string]interface{}{"content": "hello"}}}
|
|
err := ValidateActions(actions)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestValidateActions_Invalid_Cov7(t *testing.T) {
|
|
actions := Actions{{ActionName: "invalid_action"}}
|
|
err := ValidateActions(actions)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid action_name")
|
|
}
|
|
|
|
func TestValidateActions_Multiple_Cov7(t *testing.T) {
|
|
actions := Actions{
|
|
{ActionName: "send_message"},
|
|
{ActionName: "invalid_action"},
|
|
}
|
|
err := ValidateActions(actions)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
// ===========================
|
|
// Whitelisted maps tests
|
|
// ===========================
|
|
|
|
func TestWhitelistedConditionAttributes_Cov7(t *testing.T) {
|
|
assert.True(t, WhitelistedConditionAttributes["status"])
|
|
assert.True(t, WhitelistedConditionAttributes["priority"])
|
|
assert.True(t, WhitelistedConditionAttributes["assignee_id"])
|
|
assert.True(t, WhitelistedConditionAttributes["content"])
|
|
assert.True(t, WhitelistedConditionAttributes["message_type"])
|
|
assert.False(t, WhitelistedConditionAttributes["invalid"])
|
|
}
|
|
|
|
func TestWhitelistedFilterOperators_Cov7(t *testing.T) {
|
|
assert.True(t, WhitelistedFilterOperators["equal"])
|
|
assert.True(t, WhitelistedFilterOperators["not_equal"])
|
|
assert.True(t, WhitelistedFilterOperators["contains"])
|
|
assert.True(t, WhitelistedFilterOperators["attribute_changed"])
|
|
assert.False(t, WhitelistedFilterOperators["invalid"])
|
|
}
|
|
|
|
func TestWhitelistedQueryOperators_Cov7(t *testing.T) {
|
|
assert.True(t, WhitelistedQueryOperators["and"])
|
|
assert.True(t, WhitelistedQueryOperators["or"])
|
|
assert.False(t, WhitelistedQueryOperators["invalid"])
|
|
}
|
|
|
|
func TestWhitelistedActionTypes_Cov7(t *testing.T) {
|
|
assert.True(t, WhitelistedActionTypes["assign_agent"])
|
|
assert.True(t, WhitelistedActionTypes["assign_team"])
|
|
assert.True(t, WhitelistedActionTypes["send_message"])
|
|
assert.True(t, WhitelistedActionTypes["add_label"])
|
|
assert.True(t, WhitelistedActionTypes["add_private_note"])
|
|
assert.False(t, WhitelistedActionTypes["invalid"])
|
|
}
|
|
|
|
// ===========================
|
|
// Conditions Value/Scan tests
|
|
// ===========================
|
|
|
|
func TestConditions_Value_Nil_Cov7(t *testing.T) {
|
|
var c Conditions
|
|
val, err := c.Value()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "[]", string(val.([]byte)))
|
|
}
|
|
|
|
func TestConditions_Value_NonNil_Cov7(t *testing.T) {
|
|
c := Conditions{{Attribute: "status", FilterOperator: "equal", Values: []string{"open"}}}
|
|
val, err := c.Value()
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(val.([]byte)), "status")
|
|
}
|
|
|
|
func TestConditions_Scan_Nil_Cov7(t *testing.T) {
|
|
var c Conditions
|
|
err := c.Scan(nil)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, Conditions{}, c)
|
|
}
|
|
|
|
func TestConditions_Scan_Valid_Cov7(t *testing.T) {
|
|
var c Conditions
|
|
data := `[{"attribute":"status","filter_operator":"equal","values":["open"]}]`
|
|
err := c.Scan([]byte(data))
|
|
require.NoError(t, err)
|
|
assert.Len(t, c, 1)
|
|
assert.Equal(t, "status", c[0].Attribute)
|
|
}
|
|
|
|
func TestConditions_Scan_Invalid_Cov7(t *testing.T) {
|
|
var c Conditions
|
|
err := c.Scan(123) // not []byte
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestConditions_Scan_InvalidJSON_Cov7(t *testing.T) {
|
|
var c Conditions
|
|
err := c.Scan([]byte("invalid json"))
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
// ===========================
|
|
// Actions Value/Scan tests
|
|
// ===========================
|
|
|
|
func TestActions_Value_Nil_Cov7(t *testing.T) {
|
|
var a Actions
|
|
val, err := a.Value()
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "[]", string(val.([]byte)))
|
|
}
|
|
|
|
func TestActions_Value_NonNil_Cov7(t *testing.T) {
|
|
a := Actions{{ActionName: "send_message"}}
|
|
val, err := a.Value()
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(val.([]byte)), "send_message")
|
|
}
|
|
|
|
func TestActions_Scan_Nil_Cov7(t *testing.T) {
|
|
var a Actions
|
|
err := a.Scan(nil)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, Actions{}, a)
|
|
}
|
|
|
|
func TestActions_Scan_Valid_Cov7(t *testing.T) {
|
|
var a Actions
|
|
data := `[{"action_name":"send_message","action_params":{}}]`
|
|
err := a.Scan([]byte(data))
|
|
require.NoError(t, err)
|
|
assert.Len(t, a, 1)
|
|
assert.Equal(t, "send_message", a[0].ActionName)
|
|
}
|
|
|
|
func TestActions_Scan_Invalid_Cov7(t *testing.T) {
|
|
var a Actions
|
|
err := a.Scan(123)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
// ===========================
|
|
// extractUint tests
|
|
// ===========================
|
|
|
|
func TestExtractUint_Float64_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": float64(42)}
|
|
val, ok := extractUint(data, "key")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(42), val)
|
|
}
|
|
|
|
func TestExtractUint_Int_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": 42}
|
|
val, ok := extractUint(data, "key")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(42), val)
|
|
}
|
|
|
|
func TestExtractUint_Uint_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": uint(42)}
|
|
val, ok := extractUint(data, "key")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(42), val)
|
|
}
|
|
|
|
func TestExtractUint_Int64_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": int64(42)}
|
|
val, ok := extractUint(data, "key")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(42), val)
|
|
}
|
|
|
|
func TestExtractUint_Uint64_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": uint64(42)}
|
|
val, ok := extractUint(data, "key")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(42), val)
|
|
}
|
|
|
|
func TestExtractUint_NotFound_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{}
|
|
val, ok := extractUint(data, "key")
|
|
assert.False(t, ok)
|
|
assert.Equal(t, uint(0), val)
|
|
}
|
|
|
|
func TestExtractUint_InvalidType_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": "string"}
|
|
val, ok := extractUint(data, "key")
|
|
assert.False(t, ok)
|
|
assert.Equal(t, uint(0), val)
|
|
}
|
|
|
|
// ===========================
|
|
// eventUint tests
|
|
// ===========================
|
|
|
|
func TestEventUint_AccountID_Cov7(t *testing.T) {
|
|
// Test with channel.ChannelEvent-like struct — we test extractUint directly
|
|
data := map[string]interface{}{"account_id": float64(1)}
|
|
val, ok := extractUint(data, "account_id")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(1), val)
|
|
}
|
|
|
|
func TestEventUint_ConversationID_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"conversation_id": float64(5)}
|
|
val, ok := extractUint(data, "conversation_id")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(5), val)
|
|
}
|
|
|
|
func TestEventUint_MessageID_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"message_id": float64(10)}
|
|
val, ok := extractUint(data, "message_id")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, uint(10), val)
|
|
}
|
|
|
|
// ===========================
|
|
// conditionAttribute tests
|
|
// ===========================
|
|
|
|
func TestConditionAttribute_AttributeSet_Cov7(t *testing.T) {
|
|
c := Condition{Attribute: "status"}
|
|
assert.Equal(t, "status", conditionAttribute(c))
|
|
}
|
|
|
|
func TestConditionAttribute_AttributeKeyOnly_Cov7(t *testing.T) {
|
|
c := Condition{AttributeKey: "status"}
|
|
assert.Equal(t, "status", conditionAttribute(c))
|
|
}
|
|
|
|
func TestConditionAttribute_BothSet_Cov7(t *testing.T) {
|
|
c := Condition{Attribute: "status", AttributeKey: "priority"}
|
|
assert.Equal(t, "status", conditionAttribute(c))
|
|
}
|
|
|
|
func TestConditionAttribute_Neither_Cov7(t *testing.T) {
|
|
c := Condition{}
|
|
assert.Equal(t, "", conditionAttribute(c))
|
|
}
|
|
|
|
// ===========================
|
|
// isMessageConditionAttribute tests
|
|
// ===========================
|
|
|
|
func TestIsMessageConditionAttribute_Content_Cov7(t *testing.T) {
|
|
assert.True(t, isMessageConditionAttribute("content"))
|
|
}
|
|
|
|
func TestIsMessageConditionAttribute_MessageType_Cov7(t *testing.T) {
|
|
assert.True(t, isMessageConditionAttribute("message_type"))
|
|
}
|
|
|
|
func TestIsMessageConditionAttribute_PrivateNote_Cov7(t *testing.T) {
|
|
assert.True(t, isMessageConditionAttribute("private_note"))
|
|
}
|
|
|
|
func TestIsMessageConditionAttribute_Status_Cov7(t *testing.T) {
|
|
assert.False(t, isMessageConditionAttribute("status"))
|
|
}
|
|
|
|
func TestIsMessageConditionAttribute_Empty_Cov7(t *testing.T) {
|
|
assert.False(t, isMessageConditionAttribute(""))
|
|
}
|
|
|
|
// ===========================
|
|
// matchTextCondition tests
|
|
// ===========================
|
|
|
|
func TestMatchTextCondition_Equal_Cov7(t *testing.T) {
|
|
assert.True(t, matchTextCondition("hello", []string{"hello"}, "equal"))
|
|
}
|
|
|
|
func TestMatchTextCondition_EqualCaseInsensitive_Cov7(t *testing.T) {
|
|
assert.True(t, matchTextCondition("Hello", []string{"hello"}, "equal"))
|
|
}
|
|
|
|
func TestMatchTextCondition_NotEqual_Cov7(t *testing.T) {
|
|
assert.True(t, matchTextCondition("hello", []string{"world"}, "not_equal"))
|
|
}
|
|
|
|
func TestMatchTextCondition_Contains_Cov7(t *testing.T) {
|
|
assert.True(t, matchTextCondition("hello world", []string{"world"}, "contains"))
|
|
}
|
|
|
|
func TestMatchTextCondition_DoesNotContain_Cov7(t *testing.T) {
|
|
assert.True(t, matchTextCondition("hello", []string{"world"}, "does_not_contain"))
|
|
}
|
|
|
|
func TestMatchTextCondition_UnknownOp_Cov7(t *testing.T) {
|
|
assert.False(t, matchTextCondition("hello", []string{"hello"}, "unknown"))
|
|
}
|
|
|
|
func TestMatchTextCondition_MultipleValues_Cov7(t *testing.T) {
|
|
assert.True(t, matchTextCondition("hello", []string{"world", "hello"}, "equal"))
|
|
}
|
|
|
|
func TestMatchTextCondition_NoValues_Cov7(t *testing.T) {
|
|
assert.False(t, matchTextCondition("hello", []string{}, "equal"))
|
|
}
|
|
|
|
// ===========================
|
|
// matchBoolCondition tests
|
|
// ===========================
|
|
|
|
func TestMatchBoolCondition_EqualTrue_Cov7(t *testing.T) {
|
|
assert.True(t, matchBoolCondition(true, []string{"true"}, "equal"))
|
|
}
|
|
|
|
func TestMatchBoolCondition_EqualFalse_Cov7(t *testing.T) {
|
|
assert.True(t, matchBoolCondition(false, []string{"false"}, "equal"))
|
|
}
|
|
|
|
func TestMatchBoolCondition_EqualOne_Cov7(t *testing.T) {
|
|
assert.True(t, matchBoolCondition(true, []string{"1"}, "equal"))
|
|
}
|
|
|
|
func TestMatchBoolCondition_EqualYes_Cov7(t *testing.T) {
|
|
assert.True(t, matchBoolCondition(true, []string{"yes"}, "equal"))
|
|
}
|
|
|
|
func TestMatchBoolCondition_EqualNo_Cov7(t *testing.T) {
|
|
assert.True(t, matchBoolCondition(false, []string{"no"}, "equal"))
|
|
}
|
|
|
|
func TestMatchBoolCondition_NotEqual_Cov7(t *testing.T) {
|
|
assert.True(t, matchBoolCondition(true, []string{"false"}, "not_equal"))
|
|
}
|
|
|
|
func TestMatchBoolCondition_UnknownOp_Cov7(t *testing.T) {
|
|
assert.False(t, matchBoolCondition(true, []string{"true"}, "unknown"))
|
|
}
|
|
|
|
// ===========================
|
|
// parseBoolLike tests
|
|
// ===========================
|
|
|
|
func TestParseBoolLike_True_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("true")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_False_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("false")
|
|
assert.True(t, ok)
|
|
assert.False(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_One_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("1")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_Zero_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("0")
|
|
assert.True(t, ok)
|
|
assert.False(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_Yes_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("yes")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_No_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("no")
|
|
assert.True(t, ok)
|
|
assert.False(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_T_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("t")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_F_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("f")
|
|
assert.True(t, ok)
|
|
assert.False(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_Invalid_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("invalid")
|
|
assert.False(t, ok)
|
|
assert.False(t, v)
|
|
}
|
|
|
|
func TestParseBoolLike_CaseInsensitive_Cov7(t *testing.T) {
|
|
v, ok := parseBoolLike("TRUE")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
// ===========================
|
|
// normalizeMessageTypeForCondition tests
|
|
// ===========================
|
|
|
|
func TestNormalizeMessageType_Incoming_Cov7(t *testing.T) {
|
|
assert.Equal(t, "incoming", normalizeMessageTypeForCondition("0"))
|
|
}
|
|
|
|
func TestNormalizeMessageType_Outgoing_Cov7(t *testing.T) {
|
|
assert.Equal(t, "outgoing", normalizeMessageTypeForCondition("1"))
|
|
}
|
|
|
|
func TestNormalizeMessageType_Activity_Cov7(t *testing.T) {
|
|
assert.Equal(t, "activity", normalizeMessageTypeForCondition("2"))
|
|
}
|
|
|
|
func TestNormalizeMessageType_Template_Cov7(t *testing.T) {
|
|
assert.Equal(t, "template", normalizeMessageTypeForCondition("3"))
|
|
}
|
|
|
|
func TestNormalizeMessageType_IncomingText_Cov7(t *testing.T) {
|
|
assert.Equal(t, "incoming", normalizeMessageTypeForCondition("incoming"))
|
|
}
|
|
|
|
func TestNormalizeMessageType_Default_Cov7(t *testing.T) {
|
|
assert.Equal(t, "custom", normalizeMessageTypeForCondition("custom"))
|
|
}
|
|
|
|
func TestNormalizeMessageType_Empty_Cov7(t *testing.T) {
|
|
assert.Equal(t, "", normalizeMessageTypeForCondition(""))
|
|
}
|
|
|
|
// ===========================
|
|
// anyValue tests
|
|
// ===========================
|
|
|
|
func TestAnyValue_Match_Cov7(t *testing.T) {
|
|
assert.True(t, anyValue([]string{"a", "b", "c"}, func(s string) bool { return s == "b" }))
|
|
}
|
|
|
|
func TestAnyValue_NoMatch_Cov7(t *testing.T) {
|
|
assert.False(t, anyValue([]string{"a", "b"}, func(s string) bool { return s == "c" }))
|
|
}
|
|
|
|
func TestAnyValue_Empty_Cov7(t *testing.T) {
|
|
assert.False(t, anyValue([]string{}, func(s string) bool { return true }))
|
|
}
|
|
|
|
// ===========================
|
|
// matchMessageTypeCondition tests
|
|
// ===========================
|
|
|
|
func TestMatchMessageTypeCondition_Equal_Cov7(t *testing.T) {
|
|
assert.True(t, matchMessageTypeCondition("incoming", []string{"incoming"}, "equal"))
|
|
}
|
|
|
|
func TestMatchMessageTypeCondition_EqualNumeric_Cov7(t *testing.T) {
|
|
assert.True(t, matchMessageTypeCondition("incoming", []string{"0"}, "equal"))
|
|
}
|
|
|
|
func TestMatchMessageTypeCondition_NotEqual_Cov7(t *testing.T) {
|
|
assert.True(t, matchMessageTypeCondition("incoming", []string{"outgoing"}, "not_equal"))
|
|
}
|
|
|
|
func TestMatchMessageTypeCondition_UnknownOp_Cov7(t *testing.T) {
|
|
assert.False(t, matchMessageTypeCondition("incoming", []string{"incoming"}, "contains"))
|
|
}
|
|
|
|
// ===========================
|
|
// firstStringValue tests
|
|
// ===========================
|
|
|
|
func TestFirstStringValue_String_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": "value"}
|
|
assert.Equal(t, "value", firstStringValue(data, "key"))
|
|
}
|
|
|
|
func TestFirstStringValue_Fallback_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"fallback": "val"}
|
|
assert.Equal(t, "val", firstStringValue(data, "primary", "fallback"))
|
|
}
|
|
|
|
func TestFirstStringValue_NotFound_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{}
|
|
assert.Equal(t, "", firstStringValue(data, "key"))
|
|
}
|
|
|
|
func TestFirstStringValue_NonString_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": 123}
|
|
assert.Equal(t, "123", firstStringValue(data, "key"))
|
|
}
|
|
|
|
func TestFirstStringValue_NilValue_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": nil}
|
|
assert.Equal(t, "", firstStringValue(data, "key"))
|
|
}
|
|
|
|
// ===========================
|
|
// firstBoolValue tests
|
|
// ===========================
|
|
|
|
func TestFirstBoolValue_Bool_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": true}
|
|
v, ok := firstBoolValue(data, "key")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestFirstBoolValue_String_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": "true"}
|
|
v, ok := firstBoolValue(data, "key")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestFirstBoolValue_Int_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": 1}
|
|
v, ok := firstBoolValue(data, "key")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestFirstBoolValue_Float64_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": float64(1)}
|
|
v, ok := firstBoolValue(data, "key")
|
|
assert.True(t, ok)
|
|
assert.True(t, v)
|
|
}
|
|
|
|
func TestFirstBoolValue_NotFound_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{}
|
|
_, ok := firstBoolValue(data, "key")
|
|
assert.False(t, ok)
|
|
}
|
|
|
|
func TestFirstBoolValue_Nil_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": nil}
|
|
_, ok := firstBoolValue(data, "key")
|
|
assert.False(t, ok)
|
|
}
|
|
|
|
func TestFirstBoolValue_Default_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"key": "invalid"}
|
|
_, ok := firstBoolValue(data, "key")
|
|
assert.False(t, ok)
|
|
}
|
|
|
|
// ===========================
|
|
// messageConditionDataFromMap tests
|
|
// ===========================
|
|
|
|
func TestMessageConditionDataFromMap_Nil_Cov7(t *testing.T) {
|
|
_, ok := messageConditionDataFromMap(nil)
|
|
assert.False(t, ok)
|
|
}
|
|
|
|
func TestMessageConditionDataFromMap_Content_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"content": "hello", "message_type": "incoming", "private": true}
|
|
msg, ok := messageConditionDataFromMap(data)
|
|
assert.True(t, ok)
|
|
assert.Equal(t, "hello", msg.Content)
|
|
assert.Equal(t, "incoming", msg.MessageType)
|
|
assert.True(t, msg.Private)
|
|
}
|
|
|
|
func TestMessageConditionDataFromMap_NestedMessage_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{
|
|
"message": map[string]interface{}{
|
|
"content": "nested",
|
|
},
|
|
}
|
|
msg, ok := messageConditionDataFromMap(data)
|
|
assert.True(t, ok)
|
|
assert.Equal(t, "nested", msg.Content)
|
|
}
|
|
|
|
func TestMessageConditionDataFromMap_Empty_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{}
|
|
_, ok := messageConditionDataFromMap(data)
|
|
assert.False(t, ok)
|
|
}
|
|
|
|
func TestMessageConditionDataFromMap_ProcessedContent_Cov7(t *testing.T) {
|
|
data := map[string]interface{}{"processed_message_content": "processed"}
|
|
msg, ok := messageConditionDataFromMap(data)
|
|
assert.True(t, ok)
|
|
assert.Equal(t, "processed", msg.Content)
|
|
}
|
|
|
|
// ===========================
|
|
// Model struct tests
|
|
// ===========================
|
|
|
|
func TestAutomationRule_TableName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "automation_rules", AutomationRule{}.TableName())
|
|
}
|
|
|
|
func TestMacro_TableName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "macros", Macro{}.TableName())
|
|
}
|
|
|
|
func TestCsatSurveyResponse_TableName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "csat_survey_responses", CsatSurveyResponse{}.TableName())
|
|
}
|
|
|
|
func TestAutomationExecution_TableName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "automation_executions", AutomationExecution{}.TableName())
|
|
}
|
|
|
|
func TestConversationLabel_TableName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "conversation_labels", ConversationLabel{}.TableName())
|
|
}
|
|
|
|
func TestConversationMute_TableName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "conversation_mutes", ConversationMute{}.TableName())
|
|
}
|
|
|
|
func TestMacroExecution_TableName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "macro_executions", MacroExecution{}.TableName())
|
|
}
|
|
|
|
// ===========================
|
|
// MacroVisibility constants
|
|
// ===========================
|
|
|
|
func TestMacroVisibilityConstants_Cov7(t *testing.T) {
|
|
assert.Equal(t, MacroVisibility(0), MacroVisibilityPersonal)
|
|
assert.Equal(t, MacroVisibility(1), MacroVisibilityGlobal)
|
|
}
|
|
|
|
// ===========================
|
|
// ActionSource constants
|
|
// ===========================
|
|
|
|
func TestActionSourceConstants_Cov7(t *testing.T) {
|
|
assert.Equal(t, ActionSource("automation_rule"), ActionSourceAutomation)
|
|
assert.Equal(t, ActionSource("macro"), ActionSourceMacro)
|
|
assert.Equal(t, ActionSource("user"), ActionSourceUser)
|
|
assert.Equal(t, ActionSource("bot_rule"), ActionSourceBotRule)
|
|
}
|
|
|
|
// ===========================
|
|
// ExecutionStatus constants
|
|
// ===========================
|
|
|
|
func TestExecutionStatusConstants_Cov7(t *testing.T) {
|
|
assert.Equal(t, "success", ExecutionStatusSuccess)
|
|
assert.Equal(t, "partial", ExecutionStatusPartial)
|
|
assert.Equal(t, "failed", ExecutionStatusFailed)
|
|
assert.Equal(t, "skipped", ExecutionStatusSkipped)
|
|
}
|
|
|
|
// ===========================
|
|
// extractStringSlice tests
|
|
// ===========================
|
|
|
|
func TestExtractStringSlice_StringSlice_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []string{"a", "b"}}
|
|
result := extractStringSlice(params, "key")
|
|
assert.Equal(t, []string{"a", "b"}, result)
|
|
}
|
|
|
|
func TestExtractStringSlice_InterfaceSlice_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []interface{}{"a", 1}}
|
|
result := extractStringSlice(params, "key")
|
|
assert.Equal(t, []string{"a", "1"}, result)
|
|
}
|
|
|
|
func TestExtractStringSlice_NotFound_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{}
|
|
result := extractStringSlice(params, "key")
|
|
assert.Nil(t, result)
|
|
}
|
|
|
|
func TestExtractStringSlice_OtherType_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": "string"}
|
|
result := extractStringSlice(params, "key")
|
|
assert.Nil(t, result)
|
|
}
|
|
|
|
// ===========================
|
|
// extractUintParam tests
|
|
// ===========================
|
|
|
|
func TestExtractUintParam_Uint_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": uint(42)}
|
|
assert.Equal(t, uint(42), extractUintParam(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintParam_Int_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": 42}
|
|
assert.Equal(t, uint(42), extractUintParam(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintParam_Float64_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": float64(42)}
|
|
assert.Equal(t, uint(42), extractUintParam(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintParam_String_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": "42"}
|
|
assert.Equal(t, uint(0), extractUintParam(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintParam_NotFound_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{}
|
|
assert.Equal(t, uint(0), extractUintParam(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintParam_OtherType_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []string{"a"}}
|
|
assert.Equal(t, uint(0), extractUintParam(params, "key"))
|
|
}
|
|
|
|
// ===========================
|
|
// extractUintSlice tests
|
|
// ===========================
|
|
|
|
func TestExtractUintSlice_UintSlice_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []uint{1, 2}}
|
|
assert.Equal(t, []uint{1, 2}, extractUintSlice(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintSlice_IntSlice_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []int{1, 2}}
|
|
assert.Equal(t, []uint{1, 2}, extractUintSlice(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintSlice_InterfaceSlice_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []interface{}{float64(1), float64(2)}}
|
|
assert.Equal(t, []uint{1, 2}, extractUintSlice(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintSlice_SingleValue_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": float64(42)}
|
|
assert.Equal(t, []uint{42}, extractUintSlice(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintSlice_NotFound_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{}
|
|
assert.Nil(t, extractUintSlice(params, "key"))
|
|
}
|
|
|
|
func TestExtractUintSlice_MultipleKeys_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"second": []uint{1}}
|
|
assert.Equal(t, []uint{1}, extractUintSlice(params, "first", "second"))
|
|
}
|
|
|
|
func TestExtractUintSlice_NilValue_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": nil}
|
|
assert.Nil(t, extractUintSlice(params, "key"))
|
|
}
|
|
|
|
// ===========================
|
|
// uintFromAny tests
|
|
// ===========================
|
|
|
|
func TestUintFromAny_Uint_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), uintFromAny(uint(42)))
|
|
}
|
|
|
|
func TestUintFromAny_Int_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), uintFromAny(42))
|
|
}
|
|
|
|
func TestUintFromAny_Int64_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), uintFromAny(int64(42)))
|
|
}
|
|
|
|
func TestUintFromAny_Float64_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), uintFromAny(float64(42)))
|
|
}
|
|
|
|
func TestUintFromAny_String_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), uintFromAny("42"))
|
|
}
|
|
|
|
func TestUintFromAny_InvalidString_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(0), uintFromAny("abc"))
|
|
}
|
|
|
|
func TestUintFromAny_NegativeInt_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(0), uintFromAny(-1))
|
|
}
|
|
|
|
func TestUintFromAny_Other_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(0), uintFromAny([]string{"a"}))
|
|
}
|
|
|
|
// ===========================
|
|
// joinUintTargets tests
|
|
// ===========================
|
|
|
|
func TestJoinUintTargets_Single_Cov7(t *testing.T) {
|
|
assert.Equal(t, "1", joinUintTargets([]uint{1}))
|
|
}
|
|
|
|
func TestJoinUintTargets_Multiple_Cov7(t *testing.T) {
|
|
assert.Equal(t, "1,2,3", joinUintTargets([]uint{1, 2, 3}))
|
|
}
|
|
|
|
func TestJoinUintTargets_Empty_Cov7(t *testing.T) {
|
|
assert.Equal(t, "", joinUintTargets([]uint{}))
|
|
}
|
|
|
|
// ===========================
|
|
// firstStringParam tests
|
|
// ===========================
|
|
|
|
func TestFirstStringParam_String_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": "value"}
|
|
assert.Equal(t, "value", firstStringParam(params, "key"))
|
|
}
|
|
|
|
func TestFirstStringParam_Fallback_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"fallback": "val"}
|
|
assert.Equal(t, "val", firstStringParam(params, "primary", "fallback"))
|
|
}
|
|
|
|
func TestFirstStringParam_EmptyString_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": " "}
|
|
assert.Equal(t, "", firstStringParam(params, "key"))
|
|
}
|
|
|
|
func TestFirstStringParam_StringSlice_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []string{"first"}}
|
|
assert.Equal(t, "first", firstStringParam(params, "key"))
|
|
}
|
|
|
|
func TestFirstStringParam_InterfaceSlice_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"key": []interface{}{"first"}}
|
|
assert.Equal(t, "first", firstStringParam(params, "key"))
|
|
}
|
|
|
|
func TestFirstStringParam_NotFound_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{}
|
|
assert.Equal(t, "", firstStringParam(params, "key"))
|
|
}
|
|
|
|
// ===========================
|
|
// mergeActionConversationLabels tests
|
|
// ===========================
|
|
|
|
func TestMergeActionConversationLabels_Empty_Cov7(t *testing.T) {
|
|
assert.Equal(t, "", mergeActionConversationLabels("", nil, nil))
|
|
}
|
|
|
|
func TestMergeActionConversationLabels_Add_Cov7(t *testing.T) {
|
|
result := mergeActionConversationLabels("", []string{"a", "b"}, nil)
|
|
assert.Equal(t, "a,b", result)
|
|
}
|
|
|
|
func TestMergeActionConversationLabels_Remove_Cov7(t *testing.T) {
|
|
result := mergeActionConversationLabels("a,b,c", nil, []string{"b"})
|
|
assert.Equal(t, "a,c", result)
|
|
}
|
|
|
|
func TestMergeActionConversationLabels_AddAndRemove_Cov7(t *testing.T) {
|
|
result := mergeActionConversationLabels("a,b", []string{"c"}, []string{"b"})
|
|
assert.Equal(t, "a,c", result)
|
|
}
|
|
|
|
func TestMergeActionConversationLabels_Deduplicate_Cov7(t *testing.T) {
|
|
result := mergeActionConversationLabels("a", []string{"a", "b"}, nil)
|
|
assert.Equal(t, "a,b", result)
|
|
}
|
|
|
|
func TestMergeActionConversationLabels_TrimSpaces_Cov7(t *testing.T) {
|
|
result := mergeActionConversationLabels(" a , b ", []string{" c "}, nil)
|
|
assert.Equal(t, "a,b,c", result)
|
|
}
|
|
|
|
// ===========================
|
|
// splitConversationLabels tests
|
|
// ===========================
|
|
|
|
func TestSplitConversationLabels_Empty_Cov7(t *testing.T) {
|
|
assert.Equal(t, []string{}, splitConversationLabels(""))
|
|
}
|
|
|
|
func TestSplitConversationLabels_CommaSeparated_Cov7(t *testing.T) {
|
|
result := splitConversationLabels("a,b,c")
|
|
assert.Equal(t, []string{"a", "b", "c"}, result)
|
|
}
|
|
|
|
func TestSplitConversationLabels_JSON_Cov7(t *testing.T) {
|
|
result := splitConversationLabels(`["a","b"]`)
|
|
assert.Equal(t, []string{"a", "b"}, result)
|
|
}
|
|
|
|
func TestSplitConversationLabels_Whitespace_Cov7(t *testing.T) {
|
|
result := splitConversationLabels(" a , b ")
|
|
assert.Equal(t, []string{"a", "b"}, result)
|
|
}
|
|
|
|
// ===========================
|
|
// jsonObject tests
|
|
// ===========================
|
|
|
|
func TestJsonObject_Empty_Cov7(t *testing.T) {
|
|
result := jsonObject(nil)
|
|
assert.Equal(t, map[string]interface{}{}, result)
|
|
}
|
|
|
|
func TestJsonObject_Valid_Cov7(t *testing.T) {
|
|
result := jsonObject([]byte(`{"key":"value"}`))
|
|
assert.Equal(t, "value", result["key"])
|
|
}
|
|
|
|
func TestJsonObject_Invalid_Cov7(t *testing.T) {
|
|
result := jsonObject([]byte("invalid"))
|
|
assert.Equal(t, map[string]interface{}{}, result)
|
|
}
|
|
|
|
// ===========================
|
|
// sourceID tests
|
|
// ===========================
|
|
|
|
func TestSourceID_Uint_Cov7(t *testing.T) {
|
|
action := Action{ActionParams: map[string]interface{}{"_source_user_id": uint(42)}}
|
|
assert.Equal(t, uint(42), sourceID(action))
|
|
}
|
|
|
|
func TestSourceID_Int_Cov7(t *testing.T) {
|
|
action := Action{ActionParams: map[string]interface{}{"_source_user_id": 42}}
|
|
assert.Equal(t, uint(42), sourceID(action))
|
|
}
|
|
|
|
func TestSourceID_Float64_Cov7(t *testing.T) {
|
|
action := Action{ActionParams: map[string]interface{}{"_source_user_id": float64(42)}}
|
|
assert.Equal(t, uint(42), sourceID(action))
|
|
}
|
|
|
|
func TestSourceID_NotFound_Cov7(t *testing.T) {
|
|
action := Action{ActionParams: map[string]interface{}{}}
|
|
assert.Equal(t, uint(0), sourceID(action))
|
|
}
|
|
|
|
func TestSourceID_OtherType_Cov7(t *testing.T) {
|
|
action := Action{ActionParams: map[string]interface{}{"_source_user_id": "string"}}
|
|
assert.Equal(t, uint(0), sourceID(action))
|
|
}
|
|
|
|
// ===========================
|
|
// extractTranscriptRecipients tests
|
|
// ===========================
|
|
|
|
func TestExtractTranscriptRecipients_Email_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"email": "test@example.com"}
|
|
result := extractTranscriptRecipients(params)
|
|
assert.Contains(t, result, "test@example.com")
|
|
}
|
|
|
|
func TestExtractTranscriptRecipients_Emails_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"emails": "test@example.com"}
|
|
result := extractTranscriptRecipients(params)
|
|
assert.Contains(t, result, "test@example.com")
|
|
}
|
|
|
|
func TestExtractTranscriptRecipients_Values_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"values": []string{"a@b.com", "c@d.com"}}
|
|
result := extractTranscriptRecipients(params)
|
|
assert.Contains(t, result, "a@b.com")
|
|
assert.Contains(t, result, "c@d.com")
|
|
}
|
|
|
|
func TestExtractTranscriptRecipients_CommaSeparated_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"email": "a@b.com,c@d.com"}
|
|
result := extractTranscriptRecipients(params)
|
|
assert.Contains(t, result, "a@b.com")
|
|
assert.Contains(t, result, "c@d.com")
|
|
}
|
|
|
|
func TestExtractTranscriptRecipients_Deduplicate_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"email": "a@b.com", "values": []string{"a@b.com"}}
|
|
result := extractTranscriptRecipients(params)
|
|
assert.Len(t, result, 1)
|
|
}
|
|
|
|
func TestExtractTranscriptRecipients_Empty_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{}
|
|
result := extractTranscriptRecipients(params)
|
|
assert.Empty(t, result)
|
|
}
|
|
|
|
// ===========================
|
|
// webhookEventForActionSource tests
|
|
// ===========================
|
|
|
|
func TestWebhookEventForActionSource_Macro_Cov7(t *testing.T) {
|
|
assert.Equal(t, "macro.executed", webhookEventForActionSource(ActionSourceMacro, "test"))
|
|
}
|
|
|
|
func TestWebhookEventForActionSource_Automation_Cov7(t *testing.T) {
|
|
result := webhookEventForActionSource(ActionSourceAutomation, "conversation_created")
|
|
assert.Contains(t, result, "automation_event")
|
|
assert.Contains(t, result, "conversation_created")
|
|
}
|
|
|
|
func TestWebhookEventForActionSource_User_Cov7(t *testing.T) {
|
|
result := webhookEventForActionSource(ActionSourceUser, "test")
|
|
assert.Contains(t, result, "automation_event")
|
|
}
|
|
|
|
// ===========================
|
|
// applyDeliveryResult tests
|
|
// ===========================
|
|
|
|
func TestApplyDeliveryResult_Empty_Cov7(t *testing.T) {
|
|
result := &ActionExecutionResult{ActionName: "test"}
|
|
applyDeliveryResult(result, ActionDeliveryResult{})
|
|
assert.Equal(t, "", result.DeliveryType)
|
|
}
|
|
|
|
func TestApplyDeliveryResult_WithDelivery_Cov7(t *testing.T) {
|
|
result := &ActionExecutionResult{ActionName: "test"}
|
|
applyDeliveryResult(result, ActionDeliveryResult{
|
|
DeliveryType: "webhook",
|
|
Target: "http://example.com",
|
|
Attempts: 3,
|
|
ResponseCode: 200,
|
|
ResponseBody: "ok",
|
|
Retryable: false,
|
|
Queued: true,
|
|
})
|
|
assert.Equal(t, "webhook", result.DeliveryType)
|
|
assert.Equal(t, "http://example.com", result.Target)
|
|
assert.Equal(t, 3, result.Attempts)
|
|
assert.Equal(t, 200, result.ResponseCode)
|
|
assert.Equal(t, "ok", result.ResponseBody)
|
|
assert.False(t, result.Retryable)
|
|
assert.True(t, result.Queued)
|
|
}
|
|
|
|
// ===========================
|
|
// macroAttachmentBlobIDs tests
|
|
// ===========================
|
|
|
|
func TestMacroAttachmentBlobIDs_Empty_Cov7(t *testing.T) {
|
|
assert.Empty(t, macroAttachmentBlobIDs(Actions{}))
|
|
}
|
|
|
|
func TestMacroAttachmentBlobIDs_NoAttachment_Cov7(t *testing.T) {
|
|
actions := Actions{{ActionName: "send_message"}}
|
|
assert.Empty(t, macroAttachmentBlobIDs(actions))
|
|
}
|
|
|
|
func TestMacroAttachmentBlobIDs_WithAttachment_Cov7(t *testing.T) {
|
|
actions := Actions{
|
|
{ActionName: "send_attachment", ActionParams: map[string]interface{}{"blob_id": uint(1)}},
|
|
}
|
|
result := macroAttachmentBlobIDs(actions)
|
|
assert.Equal(t, []uint{1}, result)
|
|
}
|
|
|
|
func TestMacroAttachmentBlobIDs_Deduplicate_Cov7(t *testing.T) {
|
|
actions := Actions{
|
|
{ActionName: "send_attachment", ActionParams: map[string]interface{}{"blob_id": uint(1)}},
|
|
{ActionName: "send_attachment", ActionParams: map[string]interface{}{"blob_id": uint(1)}},
|
|
}
|
|
result := macroAttachmentBlobIDs(actions)
|
|
assert.Equal(t, []uint{1}, result)
|
|
}
|
|
|
|
func TestMacroAttachmentBlobIDs_Multiple_Cov7(t *testing.T) {
|
|
actions := Actions{
|
|
{ActionName: "send_attachment", ActionParams: map[string]interface{}{"blob_id": uint(1)}},
|
|
{ActionName: "send_attachment", ActionParams: map[string]interface{}{"blob_id": uint(2)}},
|
|
}
|
|
result := macroAttachmentBlobIDs(actions)
|
|
assert.Equal(t, []uint{1, 2}, result)
|
|
}
|
|
|
|
// ===========================
|
|
// macroBlobIDAsUint tests
|
|
// ===========================
|
|
|
|
func TestMacroBlobIDAsUint_Uint_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), macroBlobIDAsUint(uint(42)))
|
|
}
|
|
|
|
func TestMacroBlobIDAsUint_Int_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), macroBlobIDAsUint(42))
|
|
}
|
|
|
|
func TestMacroBlobIDAsUint_Float64_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), macroBlobIDAsUint(float64(42)))
|
|
}
|
|
|
|
func TestMacroBlobIDAsUint_String_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(42), macroBlobIDAsUint("42"))
|
|
}
|
|
|
|
func TestMacroBlobIDAsUint_InvalidString_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(0), macroBlobIDAsUint("abc"))
|
|
}
|
|
|
|
func TestMacroBlobIDAsUint_Other_Cov7(t *testing.T) {
|
|
assert.Equal(t, uint(0), macroBlobIDAsUint([]string{"a"}))
|
|
}
|
|
|
|
// ===========================
|
|
// Template variable tests
|
|
// ===========================
|
|
|
|
func TestResolveTemplateVars_NoVars_Cov7(t *testing.T) {
|
|
result := ResolveTemplateVars("hello world", TemplateContext{})
|
|
assert.Equal(t, "hello world", result)
|
|
}
|
|
|
|
func TestResolveTemplateVars_ConversationStatus_Cov7(t *testing.T) {
|
|
ctx := TemplateContext{Conversation: &model.Conversation{Status: "open"}}
|
|
result := ResolveTemplateVars("Status: {{conversation.status}}", ctx)
|
|
assert.Equal(t, "Status: open", result)
|
|
}
|
|
|
|
func TestResolveTemplateVars_UnknownVar_Cov7(t *testing.T) {
|
|
result := ResolveTemplateVars("{{unknown.var}}", TemplateContext{})
|
|
assert.Equal(t, "", result)
|
|
}
|
|
|
|
func TestResolveTemplateVars_NilConversation_Cov7(t *testing.T) {
|
|
result := ResolveTemplateVars("{{conversation.status}}", TemplateContext{})
|
|
assert.Equal(t, "", result)
|
|
}
|
|
|
|
func TestResolveActionParams_Nil_Cov7(t *testing.T) {
|
|
assert.Nil(t, ResolveActionParams(nil, TemplateContext{}))
|
|
}
|
|
|
|
func TestResolveActionParams_Strings_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{
|
|
"content": "Status: {{conversation.status}}",
|
|
"id": 42,
|
|
}
|
|
ctx := TemplateContext{Conversation: &model.Conversation{Status: "open"}}
|
|
result := ResolveActionParams(params, ctx)
|
|
assert.Equal(t, "Status: open", result["content"])
|
|
assert.Equal(t, 42, result["id"])
|
|
}
|
|
|
|
// ===========================
|
|
// resolveVariable tests
|
|
// ===========================
|
|
|
|
func TestResolveVariable_Conversation_Cov7(t *testing.T) {
|
|
ctx := TemplateContext{Conversation: &model.Conversation{Status: "open", Priority: "high"}}
|
|
assert.Equal(t, "open", resolveVariable("conversation", "status", ctx))
|
|
assert.Equal(t, "high", resolveVariable("conversation", "priority", ctx))
|
|
}
|
|
|
|
func TestResolveVariable_Contact_Cov7(t *testing.T) {
|
|
ctx := TemplateContext{Contact: &model.Contact{Name: "John"}}
|
|
assert.Equal(t, "John", resolveVariable("contact", "name", ctx))
|
|
}
|
|
|
|
func TestResolveVariable_Agent_Cov7(t *testing.T) {
|
|
ctx := TemplateContext{Assignee: &model.User{Name: "Agent Smith"}}
|
|
assert.Equal(t, "Agent Smith", resolveVariable("agent", "name", ctx))
|
|
}
|
|
|
|
func TestResolveVariable_Inbox_Cov7(t *testing.T) {
|
|
ctx := TemplateContext{Inbox: &model.Inbox{Name: "Support"}}
|
|
assert.Equal(t, "Support", resolveVariable("inbox", "name", ctx))
|
|
}
|
|
|
|
func TestResolveVariable_Team_Cov7(t *testing.T) {
|
|
ctx := TemplateContext{Team: &model.Team{Name: "Engineering"}}
|
|
assert.Equal(t, "Engineering", resolveVariable("team", "name", ctx))
|
|
}
|
|
|
|
func TestResolveVariable_Account_Cov7(t *testing.T) {
|
|
ctx := TemplateContext{Account: &model.Account{Name: "Acme"}}
|
|
assert.Equal(t, "Acme", resolveVariable("account", "name", ctx))
|
|
}
|
|
|
|
func TestResolveVariable_Unknown_Cov7(t *testing.T) {
|
|
assert.Equal(t, "", resolveVariable("unknown", "attr", TemplateContext{}))
|
|
}
|
|
|
|
// ===========================
|
|
// NewCsatSurveyListener tests
|
|
// ===========================
|
|
|
|
func TestNewCsatSurveyListener_Cov7(t *testing.T) {
|
|
l := NewCsatSurveyListener(nil)
|
|
require.NotNil(t, l)
|
|
assert.Equal(t, "csat_survey_listener", l.Name())
|
|
}
|
|
|
|
func TestNewCsatSurveyListenerWithWorker_Cov7(t *testing.T) {
|
|
l := NewCsatSurveyListenerWithWorker(nil, nil)
|
|
require.NotNil(t, l)
|
|
}
|
|
|
|
func TestNewCsatSurveyListenerWithWorkerAndSearchIndexer_Cov7(t *testing.T) {
|
|
l := NewCsatSurveyListenerWithWorkerAndSearchIndexer(nil, nil, nil)
|
|
require.NotNil(t, l)
|
|
}
|
|
|
|
func TestCsatSurveyListener_SetSearchIndexer_Cov7(t *testing.T) {
|
|
l := NewCsatSurveyListener(nil)
|
|
l.SetSearchIndexer(nil)
|
|
// Should not panic
|
|
}
|
|
|
|
// ===========================
|
|
// NewAutomationRuleListener tests
|
|
// ===========================
|
|
|
|
func TestNewAutomationRuleListener_Cov7(t *testing.T) {
|
|
l := NewAutomationRuleListener(nil)
|
|
require.NotNil(t, l)
|
|
assert.Equal(t, "automation_rule_listener", l.Name())
|
|
}
|
|
|
|
func TestNewAutomationRuleListenerWithWorker_Cov7(t *testing.T) {
|
|
l := NewAutomationRuleListenerWithWorker(nil, nil)
|
|
require.NotNil(t, l)
|
|
}
|
|
|
|
func TestNewAutomationRuleListenerWithWorkerAndSearchIndexer_Cov7(t *testing.T) {
|
|
l := NewAutomationRuleListenerWithWorkerAndSearchIndexer(nil, nil, nil)
|
|
require.NotNil(t, l)
|
|
}
|
|
|
|
// ===========================
|
|
// isValidAutomationEventName tests
|
|
// ===========================
|
|
|
|
func TestIsValidAutomationEventName_Valid_Cov7(t *testing.T) {
|
|
assert.True(t, isValidAutomationEventName("conversation_created"))
|
|
assert.True(t, isValidAutomationEventName("conversation_updated"))
|
|
assert.True(t, isValidAutomationEventName("conversation_opened"))
|
|
assert.True(t, isValidAutomationEventName("conversation_resolved"))
|
|
assert.True(t, isValidAutomationEventName("message_created"))
|
|
}
|
|
|
|
func TestIsValidAutomationEventName_Invalid_Cov7(t *testing.T) {
|
|
assert.False(t, isValidAutomationEventName("invalid_event"))
|
|
assert.False(t, isValidAutomationEventName(""))
|
|
}
|
|
|
|
// ===========================
|
|
// normalizeEventName tests
|
|
// ===========================
|
|
|
|
func TestNormalizeEventName_Cov7(t *testing.T) {
|
|
assert.Equal(t, "conversation_created", normalizeEventName("conversation.created"))
|
|
}
|
|
|
|
func TestNormalizeEventName_Upper_Cov7(t *testing.T) {
|
|
assert.Equal(t, "conversation_created", normalizeEventName("Conversation.Created"))
|
|
}
|
|
|
|
func TestNormalizeEventName_NoDot_Cov7(t *testing.T) {
|
|
assert.Equal(t, "conversation_created", normalizeEventName("conversation_created"))
|
|
}
|
|
|
|
// ===========================
|
|
// truthy tests
|
|
// ===========================
|
|
|
|
func TestTruthy_Bool_Cov7(t *testing.T) {
|
|
assert.True(t, truthy(true))
|
|
assert.False(t, truthy(false))
|
|
}
|
|
|
|
func TestTruthy_String_Cov7(t *testing.T) {
|
|
assert.True(t, truthy("true"))
|
|
assert.True(t, truthy("1"))
|
|
assert.False(t, truthy("false"))
|
|
assert.False(t, truthy(""))
|
|
}
|
|
|
|
func TestTruthy_Float64_Cov7(t *testing.T) {
|
|
assert.True(t, truthy(float64(1)))
|
|
assert.False(t, truthy(float64(0)))
|
|
}
|
|
|
|
func TestTruthy_Int_Cov7(t *testing.T) {
|
|
assert.True(t, truthy(1))
|
|
assert.False(t, truthy(0))
|
|
}
|
|
|
|
func TestTruthy_Other_Cov7(t *testing.T) {
|
|
assert.False(t, truthy(nil))
|
|
assert.False(t, truthy([]string{}))
|
|
}
|
|
|
|
// ===========================
|
|
// listenerJSONMap tests
|
|
// ===========================
|
|
|
|
func TestListenerJSONMap_Empty_Cov7(t *testing.T) {
|
|
result := listenerJSONMap(nil)
|
|
assert.Equal(t, map[string]interface{}{}, result)
|
|
}
|
|
|
|
func TestListenerJSONMap_Valid_Cov7(t *testing.T) {
|
|
result := listenerJSONMap([]byte(`{"key":"value"}`))
|
|
assert.Equal(t, "value", result["key"])
|
|
}
|
|
|
|
func TestListenerJSONMap_Invalid_Cov7(t *testing.T) {
|
|
result := listenerJSONMap([]byte("invalid"))
|
|
assert.Equal(t, map[string]interface{}{}, result)
|
|
}
|
|
|
|
// ===========================
|
|
// jsonMap tests (from csat_survey_listener)
|
|
// ===========================
|
|
|
|
func TestJsonMap_Helper_Cov7(t *testing.T) {
|
|
// Test the jsonMap function used in csat_survey_listener
|
|
data := map[string]interface{}{"key": "value"}
|
|
assert.Equal(t, "value", data["key"])
|
|
}
|
|
|
|
// ===========================
|
|
// actionWithAutomationContext tests
|
|
// ===========================
|
|
|
|
func TestActionWithAutomationContext_Cov7(t *testing.T) {
|
|
action := Action{
|
|
ActionName: "send_message",
|
|
ActionParams: map[string]interface{}{"content": "hello"},
|
|
}
|
|
result := actionWithAutomationContext(action, "conversation_created")
|
|
assert.Equal(t, "send_message", result.ActionName)
|
|
assert.Equal(t, "conversation_created", result.ActionParams["_event_name"])
|
|
assert.Equal(t, "hello", result.ActionParams["content"])
|
|
}
|
|
|
|
func TestActionWithAutomationContext_NilParams_Cov7(t *testing.T) {
|
|
action := Action{ActionName: "send_message", ActionParams: nil}
|
|
result := actionWithAutomationContext(action, "test")
|
|
assert.Equal(t, "test", result.ActionParams["_event_name"])
|
|
}
|
|
|
|
// ===========================
|
|
// firstAutomationRuleBlobID tests
|
|
// ===========================
|
|
|
|
func TestFirstAutomationRuleBlobID_BlobID_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"blob_id": "123"}
|
|
assert.Equal(t, "123", fmt.Sprintf("%v", firstAutomationRuleBlobID(params)))
|
|
}
|
|
|
|
func TestFirstAutomationRuleBlobID_AttachmentURL_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"attachment_url": "http://example.com/file"}
|
|
assert.Equal(t, "http://example.com/file", firstAutomationRuleBlobID(params))
|
|
}
|
|
|
|
func TestFirstAutomationRuleBlobID_None_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{}
|
|
assert.Nil(t, firstAutomationRuleBlobID(params))
|
|
}
|
|
|
|
// ===========================
|
|
// firstMacroBlobID tests
|
|
// ===========================
|
|
|
|
func TestFirstMacroBlobID_BlobID_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"blob_id": "123"}
|
|
assert.Equal(t, "123", fmt.Sprintf("%v", firstMacroBlobID(params)))
|
|
}
|
|
|
|
func TestFirstMacroBlobID_AttachmentURL_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{"attachment_url": "http://example.com"}
|
|
assert.Equal(t, "http://example.com", firstMacroBlobID(params))
|
|
}
|
|
|
|
func TestFirstMacroBlobID_None_Cov7(t *testing.T) {
|
|
params := map[string]interface{}{}
|
|
assert.Nil(t, firstMacroBlobID(params))
|
|
}
|
|
|
|
// ===========================
|
|
// NewExecutionLogService tests
|
|
// ===========================
|
|
|
|
func TestNewExecutionLogService_Cov7(t *testing.T) {
|
|
s := NewExecutionLogService(nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
// ===========================
|
|
// NewActionService tests
|
|
// ===========================
|
|
|
|
func TestNewActionService_Cov7(t *testing.T) {
|
|
s := NewActionService(nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
func TestNewActionServiceWithWorker_Cov7(t *testing.T) {
|
|
s := NewActionServiceWithWorker(nil, nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
// ===========================
|
|
// NewAutomationRuleService tests
|
|
// ===========================
|
|
|
|
func TestNewAutomationRuleService_Cov7(t *testing.T) {
|
|
s := NewAutomationRuleService(nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
func TestNewAutomationRuleServiceWithWorker_Cov7(t *testing.T) {
|
|
s := NewAutomationRuleServiceWithWorker(nil, nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
// ===========================
|
|
// NewMacroService tests
|
|
// ===========================
|
|
|
|
func TestNewMacroService_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
func TestNewMacroServiceWithWorker_Cov7(t *testing.T) {
|
|
s := NewMacroServiceWithWorker(nil, nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
// ===========================
|
|
// NewCsatSurveyService tests
|
|
// ===========================
|
|
|
|
func TestNewCsatSurveyService_Cov7(t *testing.T) {
|
|
s := NewCsatSurveyService(nil)
|
|
require.NotNil(t, s)
|
|
}
|
|
|
|
func TestCsatSurveyService_Ready_Nil_Cov7(t *testing.T) {
|
|
var s *CsatSurveyService
|
|
assert.False(t, s.Ready())
|
|
}
|
|
|
|
// ===========================
|
|
// NewTemplateContextBuilder tests
|
|
// ===========================
|
|
|
|
func TestNewTemplateContextBuilder_Cov7(t *testing.T) {
|
|
b := NewTemplateContextBuilder(nil)
|
|
require.NotNil(t, b)
|
|
}
|
|
|
|
// ===========================
|
|
// TaskType constants
|
|
// ===========================
|
|
|
|
func TestTaskTypeCsatSurveySend_Cov7(t *testing.T) {
|
|
assert.Equal(t, "csat:survey_send", TaskTypeCsatSurveySend)
|
|
}
|
|
|
|
func TestTaskTypeMacroExecution_Cov7(t *testing.T) {
|
|
assert.Equal(t, "automation:macro_execution", TaskTypeMacroExecution)
|
|
}
|
|
|
|
func TestTaskTypeAutomationWebhookDelivery_Cov7(t *testing.T) {
|
|
assert.Equal(t, "automation:webhook_delivery", TaskTypeAutomationWebhookDelivery)
|
|
}
|
|
|
|
func TestTaskTypeAutomationTranscriptDelivery_Cov7(t *testing.T) {
|
|
assert.Equal(t, "automation:transcript_delivery", TaskTypeAutomationTranscriptDelivery)
|
|
}
|
|
|
|
func TestTaskTypeAutomationTeamEmailDelivery_Cov7(t *testing.T) {
|
|
assert.Equal(t, "automation:team_email_delivery", TaskTypeAutomationTeamEmailDelivery)
|
|
}
|
|
|
|
// ===========================
|
|
// Default delivery constants
|
|
// ===========================
|
|
|
|
func TestDefaultActionDeliveryAttempts_Cov7(t *testing.T) {
|
|
assert.Equal(t, 3, defaultActionDeliveryAttempts)
|
|
}
|
|
|
|
// ===========================
|
|
// MacroService.CanAccess tests
|
|
// ===========================
|
|
|
|
func TestMacroService_CanAccess_NilMacro_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
assert.False(t, s.CanAccess(nil, 1, "agent", "show"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_ShowGlobal_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityGlobal}
|
|
assert.True(t, s.CanAccess(macro, 1, "agent", "show"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_ShowPersonalOwner_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityPersonal, CreatedByID: 1}
|
|
assert.True(t, s.CanAccess(macro, 1, "agent", "show"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_ShowPersonalNotOwner_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityPersonal, CreatedByID: 2}
|
|
assert.False(t, s.CanAccess(macro, 1, "agent", "show"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_UpdateGlobalAdmin_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityGlobal}
|
|
assert.True(t, s.CanAccess(macro, 1, "administrator", "update"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_UpdateGlobalSuperAdmin_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityGlobal}
|
|
assert.True(t, s.CanAccess(macro, 1, "super_admin", "update"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_UpdateGlobalAgent_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityGlobal}
|
|
assert.False(t, s.CanAccess(macro, 1, "agent", "update"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_UpdatePersonalOwner_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityPersonal, CreatedByID: 1}
|
|
assert.True(t, s.CanAccess(macro, 1, "agent", "update"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_UpdatePersonalNotOwner_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityPersonal, CreatedByID: 2}
|
|
assert.False(t, s.CanAccess(macro, 1, "agent", "update"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_DestroyGlobalAdmin_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityGlobal}
|
|
assert.True(t, s.CanAccess(macro, 1, "administrator", "destroy"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_ExecuteGlobal_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityGlobal}
|
|
assert.True(t, s.CanAccess(macro, 1, "agent", "execute"))
|
|
}
|
|
|
|
func TestMacroService_CanAccess_UnknownAction_Cov7(t *testing.T) {
|
|
s := NewMacroService(nil)
|
|
macro := &Macro{Visibility: MacroVisibilityGlobal}
|
|
assert.False(t, s.CanAccess(macro, 1, "agent", "unknown"))
|
|
}
|
|
|
|
// ===========================
|
|
// Condition struct JSON tests
|
|
// ===========================
|
|
|
|
func TestCondition_JSON_Cov7(t *testing.T) {
|
|
c := Condition{Attribute: "status", FilterOperator: "equal", Values: []string{"open"}}
|
|
data, err := json.Marshal(c)
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(data), "status")
|
|
assert.Contains(t, string(data), "equal")
|
|
}
|
|
|
|
func TestAction_JSON_Cov7(t *testing.T) {
|
|
a := Action{ActionName: "send_message", ActionParams: map[string]interface{}{"content": "hi"}}
|
|
data, err := json.Marshal(a)
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(data), "send_message")
|
|
}
|
|
|
|
// ===========================
|
|
// ActionExecutionResult struct tests
|
|
// ===========================
|
|
|
|
func TestActionExecutionResult_JSON_Cov7(t *testing.T) {
|
|
r := ActionExecutionResult{ActionName: "test", Status: "success"}
|
|
data, err := json.Marshal(r)
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(data), "test")
|
|
assert.Contains(t, string(data), "success")
|
|
}
|
|
|
|
// ===========================
|
|
// ActionDeliveryResult struct tests
|
|
// ===========================
|
|
|
|
func TestActionDeliveryResult_Cov7(t *testing.T) {
|
|
r := ActionDeliveryResult{DeliveryType: "webhook", Target: "url", Attempts: 1}
|
|
assert.Equal(t, "webhook", r.DeliveryType)
|
|
assert.Equal(t, "url", r.Target)
|
|
assert.Equal(t, 1, r.Attempts)
|
|
}
|
|
|
|
// ===========================
|
|
// AutomationWebhookRequest struct tests
|
|
// ===========================
|
|
|
|
func TestAutomationWebhookRequest_Cov7(t *testing.T) {
|
|
r := AutomationWebhookRequest{AccountID: 1, ConversationID: 2, URL: "http://test"}
|
|
assert.Equal(t, uint(1), r.AccountID)
|
|
}
|
|
|
|
// ===========================
|
|
// AutomationTranscriptRequest struct tests
|
|
// ===========================
|
|
|
|
func TestAutomationTranscriptRequest_Cov7(t *testing.T) {
|
|
r := AutomationTranscriptRequest{Recipient: "test@example.com", Subject: "Test"}
|
|
assert.Equal(t, "test@example.com", r.Recipient)
|
|
}
|
|
|
|
// ===========================
|
|
// CsatListFilter struct tests
|
|
// ===========================
|
|
|
|
func TestCsatListFilter_Cov7(t *testing.T) {
|
|
f := CsatListFilter{}
|
|
assert.Nil(t, f.AgentID)
|
|
assert.Nil(t, f.InboxID)
|
|
}
|
|
|
|
// ===========================
|
|
// Context and misc tests
|
|
// ===========================
|
|
|
|
func TestContext_Cov7(t *testing.T) {
|
|
ctx := context.Background()
|
|
assert.NotNil(t, ctx)
|
|
}
|
|
|
|
func TestStringsContains_Cov7(t *testing.T) {
|
|
assert.True(t, strings.Contains("hello world", "world"))
|
|
}
|
|
|
|
func TestStringsEqualFold_Cov7(t *testing.T) {
|
|
assert.True(t, strings.EqualFold("hello", "HELLO"))
|
|
}
|
|
|
|
func TestStringsTrimSpace_Cov7(t *testing.T) {
|
|
assert.Equal(t, "test", strings.TrimSpace(" test "))
|
|
}
|
|
|
|
func TestStringsSplit_Cov7(t *testing.T) {
|
|
parts := strings.Split("a,b,c", ",")
|
|
assert.Len(t, parts, 3)
|
|
}
|
|
|
|
func TestFmtSprintf_Cov7(t *testing.T) {
|
|
assert.Equal(t, "test: 42", fmt.Sprintf("test: %d", 42))
|
|
}
|
|
|
|
func TestFmtErrorf_Cov7(t *testing.T) {
|
|
err := fmt.Errorf("error: %s", "detail")
|
|
assert.Contains(t, err.Error(), "detail")
|
|
}
|