snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/public/model/view_test.go

@@ -0,0 +1,469 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func validKanbanProps() StringInterface {
+	kanban := &KanbanProps{
+		GroupBy: KanbanGroupBy{
+			FieldID: NewId(),
+			Columns: []KanbanColumn{
+				{ID: NewId(), Name: "Todo", OptionIDs: []string{NewId()}},
+				{ID: NewId(), Name: "Done", OptionIDs: []string{NewId()}},
+			},
+		},
+	}
+	props, _ := kanban.ToProps()
+	return props
+}
+
+func validView() *View {
+	return &View{
+		Id:        NewId(),
+		ChannelId: NewId(),
+		CreatorId: NewId(),
+		Type:      ViewTypeKanban,
+		Title:     "My Kanban",
+		Props:     validKanbanProps(),
+		CreateAt:  1,
+		UpdateAt:  1,
+	}
+}
+
+func TestViewIsValid(t *testing.T) {
+	testCases := []struct {
+		Description string
+		View        *View
+		Valid       bool
+	}{
+		{
+			"valid view",
+			validView(),
+			true,
+		},
+		{
+			"missing id",
+			&View{
+				ChannelId: NewId(),
+				CreatorId: NewId(),
+				Type:      ViewTypeKanban,
+				Title:     "My Kanban",
+				CreateAt:  1,
+				UpdateAt:  1,
+			},
+			false,
+		},
+		{
+			"invalid id",
+			func() *View { v := validView(); v.Id = "invalid"; return v }(),
+			false,
+		},
+		{
+			"missing channel id",
+			func() *View { v := validView(); v.ChannelId = ""; return v }(),
+			false,
+		},
+		{
+			"invalid channel id",
+			func() *View { v := validView(); v.ChannelId = "invalid"; return v }(),
+			false,
+		},
+		{
+			"missing creator id",
+			func() *View { v := validView(); v.CreatorId = ""; return v }(),
+			false,
+		},
+		{
+			"invalid creator id",
+			func() *View { v := validView(); v.CreatorId = "invalid"; return v }(),
+			false,
+		},
+		{
+			"invalid type",
+			func() *View { v := validView(); v.Type = "invalid"; return v }(),
+			false,
+		},
+		{
+			"empty title",
+			func() *View { v := validView(); v.Title = ""; return v }(),
+			false,
+		},
+		{
+			"title at max length",
+			func() *View { v := validView(); v.Title = strings.Repeat("a", ViewTitleMaxRunes); return v }(),
+			true,
+		},
+		{
+			"title exceeds max length",
+			func() *View { v := validView(); v.Title = strings.Repeat("a", ViewTitleMaxRunes+1); return v }(),
+			false,
+		},
+		{
+			"description at max length",
+			func() *View {
+				v := validView()
+				v.Description = strings.Repeat("a", ViewDescriptionMaxRunes)
+				return v
+			}(),
+			true,
+		},
+		{
+			"description exceeds max length",
+			func() *View {
+				v := validView()
+				v.Description = strings.Repeat("a", ViewDescriptionMaxRunes+1)
+				return v
+			}(),
+			false,
+		},
+		{
+			"missing create_at",
+			func() *View { v := validView(); v.CreateAt = 0; return v }(),
+			false,
+		},
+		{
+			"missing update_at",
+			func() *View { v := validView(); v.UpdateAt = 0; return v }(),
+			false,
+		},
+		{
+			"valid view with custom kanban props",
+			func() *View {
+				v := validView()
+				v.Props = validKanbanProps()
+				return v
+			}(),
+			true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.Description, func(t *testing.T) {
+			if tc.Valid {
+				require.Nil(t, tc.View.IsValid())
+			} else {
+				require.NotNil(t, tc.View.IsValid())
+			}
+		})
+	}
+}
+
+func TestViewPreSave(t *testing.T) {
+	t.Run("generates id if empty", func(t *testing.T) {
+		v := &View{Type: ViewTypeKanban, Title: "Kanban"}
+		v.PreSave()
+		assert.True(t, IsValidId(v.Id))
+	})
+
+	t.Run("keeps existing id", func(t *testing.T) {
+		id := NewId()
+		v := &View{Id: id, Type: ViewTypeKanban, Title: "Kanban"}
+		v.PreSave()
+		assert.Equal(t, id, v.Id)
+	})
+
+	t.Run("sets create_at and update_at", func(t *testing.T) {
+		v := &View{Type: ViewTypeKanban, Title: "Kanban"}
+		v.PreSave()
+		assert.NotZero(t, v.CreateAt)
+		assert.Equal(t, v.CreateAt, v.UpdateAt)
+	})
+
+	t.Run("keeps existing create_at", func(t *testing.T) {
+		v := &View{Type: ViewTypeKanban, Title: "Kanban", CreateAt: 42}
+		v.PreSave()
+		assert.Equal(t, int64(42), v.CreateAt)
+	})
+
+	t.Run("sets delete_at to zero", func(t *testing.T) {
+		v := &View{Type: ViewTypeKanban, Title: "Kanban", DeleteAt: 99}
+		v.PreSave()
+		assert.Zero(t, v.DeleteAt)
+	})
+}
+
+func TestViewPreUpdate(t *testing.T) {
+	v := validView()
+	originalUpdateAt := v.UpdateAt
+
+	v.PreUpdate()
+
+	assert.Greater(t, v.UpdateAt, originalUpdateAt)
+}
+
+func TestViewClone(t *testing.T) {
+	t.Run("nil props clones without panicking", func(t *testing.T) {
+		v := validView()
+		v.Props = nil
+		clone := v.Clone()
+		require.NotNil(t, clone)
+		assert.Nil(t, clone.Props)
+	})
+
+	t.Run("scalar fields are equal", func(t *testing.T) {
+		v := validView()
+		clone := v.Clone()
+		assert.Equal(t, v.Id, clone.Id)
+		assert.Equal(t, v.ChannelId, clone.ChannelId)
+		assert.Equal(t, v.Title, clone.Title)
+	})
+
+	t.Run("props are independently copied", func(t *testing.T) {
+		v := validView()
+		v.Props = StringInterface{"key": "value"}
+		clone := v.Clone()
+		require.NotNil(t, clone.Props)
+		assert.NotSame(t, &v.Props, &clone.Props)
+		assert.Equal(t, v.Props["key"], clone.Props["key"])
+
+		clone.Props["key"] = "mutated"
+		assert.Equal(t, "value", v.Props["key"], "original Props must not be affected")
+	})
+}
+
+func TestViewPatch(t *testing.T) {
+	testCases := []struct {
+		Description string
+		Patch       *ViewPatch
+		Check       func(t *testing.T, v *View)
+	}{
+		{
+			"patches title",
+			&ViewPatch{Title: new("New Title")},
+			func(t *testing.T, v *View) {
+				assert.Equal(t, "New Title", v.Title)
+			},
+		},
+		{
+			"patches description",
+			&ViewPatch{Description: new("A description")},
+			func(t *testing.T, v *View) {
+				assert.Equal(t, "A description", v.Description)
+			},
+		},
+		{
+			"patches sort_order",
+			&ViewPatch{SortOrder: new(5)},
+			func(t *testing.T, v *View) {
+				assert.Equal(t, 5, v.SortOrder)
+			},
+		},
+		{
+			"patches props",
+			&ViewPatch{Props: &StringInterface{"foo": "bar"}},
+			func(t *testing.T, v *View) {
+				require.NotNil(t, v.Props)
+				assert.Equal(t, "bar", v.Props["foo"])
+			},
+		},
+		{
+			"nil fields are not applied",
+			&ViewPatch{},
+			func(t *testing.T, v *View) {
+				assert.Equal(t, "My Kanban", v.Title)
+				assert.Empty(t, v.Description)
+				assert.Zero(t, v.SortOrder)
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.Description, func(t *testing.T) {
+			v := validView()
+			v.Patch(tc.Patch)
+			tc.Check(t, v)
+		})
+	}
+
+	t.Run("patched props are independent from patch source", func(t *testing.T) {
+		patchProps := &StringInterface{"key": "value"}
+		v := validView()
+		v.Patch(&ViewPatch{Props: patchProps})
+		require.NotNil(t, v.Props)
+
+		(*patchProps)["key"] = "mutated"
+		assert.Equal(t, "value", v.Props["key"], "view Props must not be affected by patch mutation")
+	})
+}
+
+func TestKanbanPropsValidation(t *testing.T) {
+	t.Run("nil props rejected for kanban", func(t *testing.T) {
+		v := validView()
+		v.Props = nil
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("empty props rejected for kanban", func(t *testing.T) {
+		v := validView()
+		v.Props = StringInterface{}
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("missing field_id rejected", func(t *testing.T) {
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: "",
+				Columns: []KanbanColumn{
+					{ID: NewId(), Name: "Todo", OptionIDs: []string{NewId()}},
+				},
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("invalid field_id rejected", func(t *testing.T) {
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: "not-a-valid-id",
+				Columns: []KanbanColumn{
+					{ID: NewId(), Name: "Todo", OptionIDs: []string{NewId()}},
+				},
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("empty columns rejected", func(t *testing.T) {
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: NewId(),
+				Columns: []KanbanColumn{},
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("too many columns rejected", func(t *testing.T) {
+		columns := make([]KanbanColumn, MaxKanbanColumns+1)
+		for i := range columns {
+			columns[i] = KanbanColumn{ID: NewId(), Name: "Col", OptionIDs: []string{NewId()}}
+		}
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: NewId(),
+				Columns: columns,
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("max columns accepted", func(t *testing.T) {
+		columns := make([]KanbanColumn, MaxKanbanColumns)
+		for i := range columns {
+			columns[i] = KanbanColumn{ID: NewId(), Name: "Col", OptionIDs: []string{NewId()}}
+		}
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: NewId(),
+				Columns: columns,
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.Nil(t, v.IsValid())
+	})
+
+	t.Run("column missing id rejected", func(t *testing.T) {
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: NewId(),
+				Columns: []KanbanColumn{
+					{ID: "", Name: "Todo", OptionIDs: []string{NewId()}},
+				},
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("column empty name rejected", func(t *testing.T) {
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: NewId(),
+				Columns: []KanbanColumn{
+					{ID: NewId(), Name: "", OptionIDs: []string{NewId()}},
+				},
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("column empty option_ids rejected", func(t *testing.T) {
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: NewId(),
+				Columns: []KanbanColumn{
+					{ID: NewId(), Name: "Todo", OptionIDs: []string{}},
+				},
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.NotNil(t, v.IsValid())
+	})
+
+	t.Run("column with multiple option_ids accepted", func(t *testing.T) {
+		kanban := &KanbanProps{
+			GroupBy: KanbanGroupBy{
+				FieldID: NewId(),
+				Columns: []KanbanColumn{
+					{ID: NewId(), Name: "Todo", OptionIDs: []string{NewId(), NewId()}},
+				},
+			},
+		}
+		props, _ := kanban.ToProps()
+		v := validView()
+		v.Props = props
+		require.Nil(t, v.IsValid())
+	})
+}
+
+func TestKanbanPropsRoundTrip(t *testing.T) {
+	original := &KanbanProps{
+		GroupBy: KanbanGroupBy{
+			FieldID: NewId(),
+			Columns: []KanbanColumn{
+				{ID: NewId(), Name: "Todo", OptionIDs: []string{NewId()}},
+				{ID: NewId(), Name: "Done", OptionIDs: []string{NewId(), NewId()}},
+			},
+		},
+	}
+
+	props, err := original.ToProps()
+	require.NoError(t, err)
+
+	parsed, err := KanbanPropsFromProps(props)
+	require.NoError(t, err)
+
+	assert.Equal(t, original.GroupBy.FieldID, parsed.GroupBy.FieldID)
+	require.Len(t, parsed.GroupBy.Columns, 2)
+	assert.Equal(t, original.GroupBy.Columns[0].Name, parsed.GroupBy.Columns[0].Name)
+	assert.Equal(t, original.GroupBy.Columns[1].OptionIDs, parsed.GroupBy.Columns[1].OptionIDs)
+}