mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
7aec4c4654
* Updates search opts and cursor for searching property fields * Adds store changes and tests to accomodate the new search options * Add an index for improving delta query efficiency * Enhances the get property fields endpoint to support deltas and hierarchical searches * Adds new fields search endpoint * Adds since to the property values endpoints * Adds property value endpoint documentation * Fix linter * Address coderabbit comments * Complete i18n * Minor improvements * Consistently apply DWIM semantics around object_type system * Add support for DM/GMs * Move auditRec to the top of the searchPropertyFieldsCore method * Update since mechanics to use greater or equal * Update API docs * Updated tests to filter after the semantics changes --------- Co-authored-by: Miguel de la Cruz <[email protected]>
379 lines
9.6 KiB
Go
379 lines
9.6 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package model
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestPropertyValue_PreSave(t *testing.T) {
|
|
t.Run("sets ID if empty", func(t *testing.T) {
|
|
pv := &PropertyValue{}
|
|
pv.PreSave()
|
|
assert.NotEmpty(t, pv.ID)
|
|
assert.Len(t, pv.ID, 26) // Length of NewId()
|
|
})
|
|
|
|
t.Run("keeps existing ID", func(t *testing.T) {
|
|
pv := &PropertyValue{ID: "existing_id"}
|
|
pv.PreSave()
|
|
assert.Equal(t, "existing_id", pv.ID)
|
|
})
|
|
|
|
t.Run("sets CreateAt if zero", func(t *testing.T) {
|
|
pv := &PropertyValue{}
|
|
pv.PreSave()
|
|
assert.NotZero(t, pv.CreateAt)
|
|
})
|
|
|
|
t.Run("sets UpdateAt equal to CreateAt", func(t *testing.T) {
|
|
pv := &PropertyValue{}
|
|
pv.PreSave()
|
|
assert.Equal(t, pv.CreateAt, pv.UpdateAt)
|
|
})
|
|
}
|
|
|
|
func TestPropertyValue_IsValid(t *testing.T) {
|
|
t.Run("valid value", func(t *testing.T) {
|
|
value := json.RawMessage(`{"test": "value"}`)
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: "test_type",
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
Value: value,
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.NoError(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("invalid ID", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: "invalid",
|
|
TargetID: NewId(),
|
|
TargetType: "test_type",
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("invalid TargetID", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: "invalid",
|
|
TargetType: "test_type",
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("empty TargetType", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: "",
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("invalid GroupID", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: "test_type",
|
|
GroupID: "invalid",
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("invalid FieldID", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: "test_type",
|
|
GroupID: NewId(),
|
|
FieldID: "invalid",
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("zero CreateAt", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: "test_type",
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: 0,
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("zero UpdateAt", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: "test_type",
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: 0,
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("TargetType exceeds maximum length", func(t *testing.T) {
|
|
longTargetType := strings.Repeat("a", PropertyValueTargetTypeMaxRunes+1)
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: longTargetType,
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("TargetType at maximum length is valid", func(t *testing.T) {
|
|
maxLengthTargetType := strings.Repeat("a", PropertyValueTargetTypeMaxRunes)
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: maxLengthTargetType,
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.NoError(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("system TargetType with system sentinel TargetID is valid", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: PropertyValueSystemTargetID,
|
|
TargetType: PropertyValueTargetTypeSystem,
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.NoError(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("system TargetType with arbitrary TargetID is invalid", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: NewId(),
|
|
TargetType: PropertyValueTargetTypeSystem,
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
|
|
t.Run("non-system TargetType with system sentinel TargetID is invalid", func(t *testing.T) {
|
|
pv := &PropertyValue{
|
|
ID: NewId(),
|
|
TargetID: PropertyValueSystemTargetID,
|
|
TargetType: PropertyValueTargetTypeChannel,
|
|
GroupID: NewId(),
|
|
FieldID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
require.Error(t, pv.IsValid())
|
|
})
|
|
}
|
|
|
|
func TestPropertyValueSearchCursor_IsValid(t *testing.T) {
|
|
t.Run("empty cursor is valid", func(t *testing.T) {
|
|
cursor := PropertyValueSearchCursor{}
|
|
assert.NoError(t, cursor.IsValid())
|
|
})
|
|
|
|
t.Run("valid cursor with CreateAt", func(t *testing.T) {
|
|
cursor := PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
}
|
|
assert.NoError(t, cursor.IsValid())
|
|
})
|
|
|
|
t.Run("valid cursor with UpdateAt", func(t *testing.T) {
|
|
cursor := PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
assert.NoError(t, cursor.IsValid())
|
|
})
|
|
|
|
t.Run("invalid PropertyValueID", func(t *testing.T) {
|
|
cursor := PropertyValueSearchCursor{
|
|
PropertyValueID: "invalid",
|
|
CreateAt: GetMillis(),
|
|
}
|
|
assert.Error(t, cursor.IsValid())
|
|
})
|
|
|
|
t.Run("neither CreateAt nor UpdateAt set", func(t *testing.T) {
|
|
cursor := PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
}
|
|
assert.Error(t, cursor.IsValid())
|
|
})
|
|
|
|
t.Run("both CreateAt and UpdateAt set", func(t *testing.T) {
|
|
cursor := PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
CreateAt: GetMillis(),
|
|
UpdateAt: GetMillis(),
|
|
}
|
|
assert.Error(t, cursor.IsValid())
|
|
})
|
|
|
|
t.Run("negative CreateAt", func(t *testing.T) {
|
|
cursor := PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
CreateAt: -1,
|
|
}
|
|
assert.Error(t, cursor.IsValid())
|
|
})
|
|
}
|
|
|
|
func TestPropertyValueSearchOpts_IsValid(t *testing.T) {
|
|
t.Run("empty opts is valid", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{}
|
|
assert.NoError(t, opts.IsValid())
|
|
})
|
|
|
|
t.Run("since without cursor is valid", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{SinceUpdateAt: 1000}
|
|
assert.NoError(t, opts.IsValid())
|
|
})
|
|
|
|
t.Run("delta mode with matching cursor_update_at is valid", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{
|
|
SinceUpdateAt: 1000,
|
|
Cursor: PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
UpdateAt: 1500,
|
|
},
|
|
}
|
|
assert.NoError(t, opts.IsValid())
|
|
})
|
|
|
|
t.Run("directory mode with matching cursor_create_at is valid", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{
|
|
Cursor: PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
CreateAt: 1500,
|
|
},
|
|
}
|
|
assert.NoError(t, opts.IsValid())
|
|
})
|
|
|
|
t.Run("delta mode with cursor_create_at is invalid", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{
|
|
SinceUpdateAt: 1000,
|
|
Cursor: PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
CreateAt: 1500,
|
|
},
|
|
}
|
|
assert.Error(t, opts.IsValid())
|
|
})
|
|
|
|
t.Run("directory mode with cursor_update_at is invalid", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{
|
|
Cursor: PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
UpdateAt: 1500,
|
|
},
|
|
}
|
|
assert.Error(t, opts.IsValid())
|
|
})
|
|
|
|
t.Run("invalid cursor surfaces error", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{
|
|
Cursor: PropertyValueSearchCursor{
|
|
PropertyValueID: "invalid",
|
|
CreateAt: 1500,
|
|
},
|
|
}
|
|
assert.Error(t, opts.IsValid())
|
|
})
|
|
|
|
t.Run("cursor with ID but neither create_at nor update_at is invalid", func(t *testing.T) {
|
|
opts := PropertyValueSearchOpts{
|
|
Cursor: PropertyValueSearchCursor{
|
|
PropertyValueID: NewId(),
|
|
},
|
|
}
|
|
assert.Error(t, opts.IsValid())
|
|
})
|
|
}
|
|
|
|
func TestSanitizePropertyValue(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{"empty bytes", "", ""},
|
|
{"string trimmed", `" hello "`, `"hello"`},
|
|
{"string unchanged", `"hello"`, `"hello"`},
|
|
{"string all whitespace", `" "`, `""`},
|
|
{"string already empty", `""`, `""`},
|
|
{"string array trimmed and filtered", `[" a ", "", " ", "b"]`, `["a","b"]`},
|
|
{"string array unchanged", `["a","b"]`, `["a","b"]`},
|
|
{"string array all empty", `["", " ", ""]`, `[]`},
|
|
{"number passthrough", `42`, `42`},
|
|
{"boolean passthrough", `true`, `true`},
|
|
{"null passthrough", `null`, `null`},
|
|
{"object passthrough", `{"key":" val "}`, `{"key":" val "}`},
|
|
{"nested array passthrough", `[["a","b"]]`, `[["a","b"]]`},
|
|
{"mixed array passthrough", `["a",1]`, `["a",1]`},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got := SanitizePropertyValue(json.RawMessage(tc.in))
|
|
assert.Equal(t, tc.want, string(got))
|
|
})
|
|
}
|
|
|
|
t.Run("returns identity when no change", func(t *testing.T) {
|
|
raw := json.RawMessage(`"hello"`)
|
|
got := SanitizePropertyValue(raw)
|
|
assert.Equal(t, &raw[0], &got[0], "expected same backing array when unchanged")
|
|
})
|
|
}
|