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

server/public/model/shared_channel_test.go

@@ -0,0 +1,519 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSharedChannelIsValid(t *testing.T) {
+	id := NewId()
+	now := GetMillis()
+	data := []struct {
+		name  string
+		sc    *SharedChannel
+		valid bool
+	}{
+		{name: "Zero value", sc: &SharedChannel{}, valid: false},
+		{name: "Missing team_id", sc: &SharedChannel{ChannelId: id}, valid: false},
+		{name: "Missing create_at", sc: &SharedChannel{ChannelId: id, TeamId: id}, valid: false},
+		{name: "Missing update_at", sc: &SharedChannel{ChannelId: id, TeamId: id, CreateAt: now}, valid: false},
+		{name: "Missing share_name", sc: &SharedChannel{ChannelId: id, TeamId: id, CreateAt: now, UpdateAt: now}, valid: false},
+		{name: "Invalid share_name", sc: &SharedChannel{ChannelId: id, TeamId: id, CreateAt: now, UpdateAt: now,
+			ShareName: "@test@"}, valid: false},
+		{name: "Too long share_name", sc: &SharedChannel{ChannelId: id, TeamId: id, CreateAt: now, UpdateAt: now,
+			ShareName: strings.Repeat("01234567890", 100)}, valid: false},
+		{name: "Missing creator_id", sc: &SharedChannel{ChannelId: id, TeamId: id, CreateAt: now, UpdateAt: now,
+			ShareName: "test"}, valid: false},
+		{name: "Missing remote_id", sc: &SharedChannel{ChannelId: id, TeamId: id, CreateAt: now, UpdateAt: now,
+			ShareName: "test", CreatorId: id}, valid: false},
+		{name: "Valid shared channel", sc: &SharedChannel{ChannelId: id, TeamId: id, CreateAt: now, UpdateAt: now,
+			ShareName: "test", CreatorId: id, RemoteId: id}, valid: true},
+	}
+
+	for _, item := range data {
+		appErr := item.sc.IsValid()
+		if item.valid {
+			assert.Nil(t, appErr, item.name)
+		} else {
+			assert.NotNil(t, appErr, item.name)
+		}
+	}
+}
+
+func TestSharedChannelPreSave(t *testing.T) {
+	now := GetMillis()
+
+	o := SharedChannel{ChannelId: NewId(), ShareName: "test"}
+	o.PreSave()
+
+	require.GreaterOrEqual(t, o.CreateAt, now)
+	require.GreaterOrEqual(t, o.UpdateAt, now)
+}
+
+func TestSharedChannelPreUpdate(t *testing.T) {
+	now := GetMillis()
+
+	o := SharedChannel{ChannelId: NewId(), ShareName: "test"}
+	o.PreUpdate()
+
+	require.GreaterOrEqual(t, o.UpdateAt, now)
+}
+
+func TestSyncMsgXMLRoundTrip(t *testing.T) {
+	remoteID := NewId()
+	msg := &SyncMsg{
+		Id:        NewId(),
+		ChannelId: NewId(),
+		Users: map[string]*User{
+			"user1": {
+				Id:       NewId(),
+				Username: "testuser1",
+				Email:    "test1@example.com",
+				Props:    StringMap{"key1": "val1"},
+				Timezone: StringMap{"useAutomaticTimezone": "true"},
+			},
+			"user2": {
+				Id:       NewId(),
+				Username: "testuser2",
+				Email:    "test2@example.com",
+			},
+		},
+		Posts: []*Post{
+			{
+				Id:        NewId(),
+				ChannelId: NewId(),
+				UserId:    NewId(),
+				Message:   "hello world",
+				Props:     StringInterface{"from_webhook": "true", "count": float64(42)},
+				RemoteId:  &remoteID,
+			},
+		},
+		Reactions: []*Reaction{
+			{
+				UserId:    NewId(),
+				PostId:    NewId(),
+				EmojiName: "thumbsup",
+				CreateAt:  1000,
+			},
+		},
+		Statuses: []*Status{
+			{
+				UserId: NewId(),
+				Status: StatusOnline,
+			},
+		},
+		MembershipChanges: []*MembershipChangeMsg{
+			{
+				ChannelId:  NewId(),
+				UserId:     NewId(),
+				IsAdd:      true,
+				RemoteId:   NewId(),
+				ChangeTime: 2000,
+			},
+		},
+		Acknowledgements: []*PostAcknowledgement{
+			{
+				UserId:         NewId(),
+				PostId:         NewId(),
+				AcknowledgedAt: 3000,
+				ChannelId:      NewId(),
+			},
+		},
+		MentionTransforms: map[string]string{
+			"@olduser": "@newuser",
+			"@admin":   "@remote_admin",
+		},
+	}
+
+	data, err := xml.MarshalIndent(msg, "", "  ")
+	require.NoError(t, err)
+
+	var decoded SyncMsg
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, msg.Id, decoded.Id)
+	assert.Equal(t, msg.ChannelId, decoded.ChannelId)
+	assert.Len(t, decoded.Users, 2)
+	assert.Equal(t, msg.Users["user1"].Username, decoded.Users["user1"].Username)
+	assert.Equal(t, msg.Users["user2"].Username, decoded.Users["user2"].Username)
+	assert.Len(t, decoded.Posts, 1)
+	assert.Equal(t, msg.Posts[0].Message, decoded.Posts[0].Message)
+	assert.Len(t, decoded.Reactions, 1)
+	assert.Equal(t, msg.Reactions[0].EmojiName, decoded.Reactions[0].EmojiName)
+	assert.Len(t, decoded.Statuses, 1)
+	assert.Equal(t, msg.Statuses[0].Status, decoded.Statuses[0].Status)
+	assert.Len(t, decoded.MembershipChanges, 1)
+	assert.Equal(t, msg.MembershipChanges[0].IsAdd, decoded.MembershipChanges[0].IsAdd)
+	assert.Len(t, decoded.Acknowledgements, 1)
+	assert.Equal(t, msg.Acknowledgements[0].AcknowledgedAt, decoded.Acknowledgements[0].AcknowledgedAt)
+	assert.Equal(t, msg.MentionTransforms, decoded.MentionTransforms)
+}
+
+func TestSyncMsgXMLUsersMap(t *testing.T) {
+	msg := &SyncMsg{
+		Id: NewId(),
+		Users: map[string]*User{
+			"alpha": {Id: "id-alpha", Username: "alpha"},
+			"beta":  {Id: "id-beta", Username: "beta"},
+			"gamma": {Id: "id-gamma", Username: "gamma"},
+		},
+	}
+
+	data, err := xml.Marshal(msg)
+	require.NoError(t, err)
+
+	var decoded SyncMsg
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	require.Len(t, decoded.Users, 3)
+	assert.Equal(t, "alpha", decoded.Users["alpha"].Username)
+	assert.Equal(t, "beta", decoded.Users["beta"].Username)
+	assert.Equal(t, "gamma", decoded.Users["gamma"].Username)
+}
+
+func TestSyncMsgXMLMentionTransforms(t *testing.T) {
+	msg := &SyncMsg{
+		Id: NewId(),
+		MentionTransforms: map[string]string{
+			"@user1": "@remote_user1",
+			"@user2": "@remote_user2",
+		},
+	}
+
+	data, err := xml.Marshal(msg)
+	require.NoError(t, err)
+
+	var decoded SyncMsg
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, msg.MentionTransforms, decoded.MentionTransforms)
+}
+
+func TestSyncMsgXMLEmptyMaps(t *testing.T) {
+	msg := &SyncMsg{
+		Id:        NewId(),
+		ChannelId: NewId(),
+	}
+
+	data, err := xml.Marshal(msg)
+	require.NoError(t, err)
+
+	var decoded SyncMsg
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, msg.Id, decoded.Id)
+	assert.Equal(t, msg.ChannelId, decoded.ChannelId)
+	assert.Nil(t, decoded.Users)
+	assert.Nil(t, decoded.MentionTransforms)
+}
+
+func TestPostXMLRoundTrip(t *testing.T) {
+	remoteID := NewId()
+	post := &Post{
+		Id:        NewId(),
+		CreateAt:  1000,
+		UpdateAt:  2000,
+		UserId:    NewId(),
+		ChannelId: NewId(),
+		Message:   "test message with <xml> special & chars",
+		Props: StringInterface{
+			"from_webhook": "true",
+			"count":        float64(42),
+			"nested":       map[string]any{"a": float64(1), "b": "two"},
+		},
+		FileIds:  StringArray{"file1", "file2"},
+		RemoteId: &remoteID,
+		Metadata: &PostMetadata{}, // should be excluded from XML
+	}
+
+	data, err := xml.MarshalIndent(post, "", "  ")
+	require.NoError(t, err)
+
+	var decoded Post
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, post.Id, decoded.Id)
+	assert.Equal(t, post.Message, decoded.Message)
+	assert.Equal(t, post.CreateAt, decoded.CreateAt)
+	assert.Equal(t, "true", decoded.Props["from_webhook"])
+	assert.Equal(t, float64(42), decoded.Props["count"])
+	assert.Equal(t, post.FileIds, decoded.FileIds)
+	assert.Equal(t, *post.RemoteId, *decoded.RemoteId)
+	assert.Nil(t, decoded.Metadata, "Metadata should be excluded from XML")
+}
+
+func TestUserXMLRoundTrip(t *testing.T) {
+	remoteID := NewId()
+	user := &User{
+		Id:          NewId(),
+		Username:    "testuser",
+		Email:       "test@example.com",
+		FirstName:   "Test",
+		LastName:    "User",
+		Props:       StringMap{"customkey": "customval"},
+		NotifyProps: StringMap{"push": "all", "desktop": "mention"},
+		Timezone:    StringMap{"useAutomaticTimezone": "true", "manualTimezone": "America/New_York"},
+		RemoteId:    &remoteID,
+	}
+
+	data, err := xml.MarshalIndent(user, "", "  ")
+	require.NoError(t, err)
+
+	var decoded User
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, user.Id, decoded.Id)
+	assert.Equal(t, user.Username, decoded.Username)
+	assert.Equal(t, user.Email, decoded.Email)
+	assert.Equal(t, user.Props, decoded.Props)
+	assert.Equal(t, user.NotifyProps, decoded.NotifyProps)
+	assert.Equal(t, user.Timezone, decoded.Timezone)
+	assert.Equal(t, *user.RemoteId, *decoded.RemoteId)
+}
+
+func TestReactionXMLRoundTrip(t *testing.T) {
+	remoteID := NewId()
+	reaction := &Reaction{
+		UserId:    NewId(),
+		PostId:    NewId(),
+		EmojiName: "thumbsup",
+		CreateAt:  1000,
+		UpdateAt:  2000,
+		RemoteId:  &remoteID,
+		ChannelId: NewId(),
+	}
+
+	data, err := xml.Marshal(reaction)
+	require.NoError(t, err)
+
+	var decoded Reaction
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, reaction.UserId, decoded.UserId)
+	assert.Equal(t, reaction.PostId, decoded.PostId)
+	assert.Equal(t, reaction.EmojiName, decoded.EmojiName)
+	assert.Equal(t, reaction.CreateAt, decoded.CreateAt)
+	assert.Equal(t, *reaction.RemoteId, *decoded.RemoteId)
+}
+
+func TestStatusXMLRoundTrip(t *testing.T) {
+	status := &Status{
+		UserId:         NewId(),
+		Status:         StatusOnline,
+		Manual:         true,
+		LastActivityAt: 5000,
+		DNDEndTime:     6000,
+		PrevStatus:     StatusAway, // should be excluded
+	}
+
+	data, err := xml.Marshal(status)
+	require.NoError(t, err)
+
+	var decoded Status
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, status.UserId, decoded.UserId)
+	assert.Equal(t, status.Status, decoded.Status)
+	assert.Equal(t, status.Manual, decoded.Manual)
+	assert.Equal(t, status.DNDEndTime, decoded.DNDEndTime)
+	assert.Empty(t, decoded.PrevStatus, "PrevStatus should be excluded from XML")
+}
+
+func TestPostAcknowledgementXMLRoundTrip(t *testing.T) {
+	remoteID := NewId()
+	ack := &PostAcknowledgement{
+		UserId:         NewId(),
+		PostId:         NewId(),
+		AcknowledgedAt: 3000,
+		ChannelId:      NewId(),
+		RemoteId:       &remoteID,
+	}
+
+	data, err := xml.Marshal(ack)
+	require.NoError(t, err)
+
+	var decoded PostAcknowledgement
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, ack.UserId, decoded.UserId)
+	assert.Equal(t, ack.PostId, decoded.PostId)
+	assert.Equal(t, ack.AcknowledgedAt, decoded.AcknowledgedAt)
+	assert.Equal(t, ack.ChannelId, decoded.ChannelId)
+	assert.Equal(t, *ack.RemoteId, *decoded.RemoteId)
+}
+
+func TestFileInfoXMLRoundTrip(t *testing.T) {
+	remoteID := NewId()
+	fi := &FileInfo{
+		Id:            NewId(),
+		CreatorId:     NewId(),
+		PostId:        NewId(),
+		ChannelId:     NewId(),
+		CreateAt:      1000,
+		UpdateAt:      2000,
+		Name:          "test.txt",
+		Extension:     "txt",
+		Size:          1024,
+		MimeType:      "text/plain",
+		RemoteId:      &remoteID,
+		Path:          "/data/test.txt",
+		ThumbnailPath: "/data/test_thumb.txt",
+		PreviewPath:   "/data/test_preview.txt",
+		Content:       "file content for search",
+	}
+
+	data, err := xml.Marshal(fi)
+	require.NoError(t, err)
+
+	var decoded FileInfo
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, fi.Id, decoded.Id)
+	assert.Equal(t, fi.CreatorId, decoded.CreatorId)
+	assert.Equal(t, fi.Name, decoded.Name)
+	assert.Equal(t, fi.Size, decoded.Size)
+	assert.Equal(t, *fi.RemoteId, *decoded.RemoteId)
+	assert.Empty(t, decoded.Path, "Path should be excluded from XML")
+	assert.Empty(t, decoded.ThumbnailPath, "ThumbnailPath should be excluded from XML")
+	assert.Empty(t, decoded.PreviewPath, "PreviewPath should be excluded from XML")
+	assert.Empty(t, decoded.Content, "Content should be excluded from XML")
+}
+
+func TestStringMapXMLRoundTrip(t *testing.T) {
+	m := StringMap{
+		"key1":  "value1",
+		"key2":  "value2",
+		"empty": "",
+	}
+
+	data, err := xml.Marshal(m)
+	require.NoError(t, err)
+
+	var decoded StringMap
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, m, decoded)
+}
+
+func TestStringInterfaceXMLRoundTrip(t *testing.T) {
+	m := StringInterface{
+		"string_val": "hello",
+		"number_val": float64(42),
+		"bool_val":   true,
+		"null_val":   nil,
+		"nested":     map[string]any{"a": float64(1), "b": "two"},
+	}
+
+	data, err := xml.Marshal(m)
+	require.NoError(t, err)
+
+	var decoded StringInterface
+	err = xml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	assert.Equal(t, "hello", decoded["string_val"])
+	assert.Equal(t, float64(42), decoded["number_val"])
+	assert.Equal(t, true, decoded["bool_val"])
+	assert.Nil(t, decoded["null_val"])
+	nested, ok := decoded["nested"].(map[string]any)
+	require.True(t, ok)
+	assert.Equal(t, float64(1), nested["a"])
+	assert.Equal(t, "two", nested["b"])
+}
+
+func TestXMLDoesNotAffectJSON(t *testing.T) {
+	remoteID := NewId()
+
+	t.Run("SyncMsg", func(t *testing.T) {
+		msg := &SyncMsg{
+			Id:        NewId(),
+			ChannelId: NewId(),
+			Users: map[string]*User{
+				"u1": {Id: NewId(), Username: "u1"},
+			},
+			Posts:             []*Post{{Id: NewId(), Message: "test"}},
+			MentionTransforms: map[string]string{"@a": "@b"},
+		}
+		data, err := json.Marshal(msg)
+		require.NoError(t, err)
+
+		var decoded SyncMsg
+		err = json.Unmarshal(data, &decoded)
+		require.NoError(t, err)
+		assert.Equal(t, msg.Id, decoded.Id)
+		assert.Equal(t, msg.Users["u1"].Username, decoded.Users["u1"].Username)
+		assert.Equal(t, msg.MentionTransforms, decoded.MentionTransforms)
+	})
+
+	t.Run("Post", func(t *testing.T) {
+		post := &Post{
+			Id:       NewId(),
+			Message:  "test",
+			Props:    StringInterface{"key": "val"},
+			RemoteId: &remoteID,
+			Metadata: &PostMetadata{},
+		}
+		data, err := json.Marshal(post)
+		require.NoError(t, err)
+
+		var decoded Post
+		err = json.Unmarshal(data, &decoded)
+		require.NoError(t, err)
+		assert.Equal(t, post.Id, decoded.Id)
+		assert.Equal(t, post.Props["key"], decoded.Props["key"])
+		assert.NotNil(t, decoded.Metadata, "Metadata should be present in JSON")
+	})
+
+	t.Run("User", func(t *testing.T) {
+		user := &User{
+			Id:       NewId(),
+			Username: "test",
+			Props:    StringMap{"k": "v"},
+			Timezone: StringMap{"tz": "utc"},
+		}
+		data, err := json.Marshal(user)
+		require.NoError(t, err)
+
+		var decoded User
+		err = json.Unmarshal(data, &decoded)
+		require.NoError(t, err)
+		assert.Equal(t, user.Id, decoded.Id)
+		assert.Equal(t, user.Props, decoded.Props)
+		assert.Equal(t, user.Timezone, decoded.Timezone)
+	})
+
+	t.Run("SyncResponse", func(t *testing.T) {
+		sr := &SyncResponse{
+			UsersLastUpdateAt: 1000,
+			UserErrors:        []string{"err1"},
+			PostsLastUpdateAt: 2000,
+		}
+		data, err := json.Marshal(sr)
+		require.NoError(t, err)
+
+		var decoded SyncResponse
+		err = json.Unmarshal(data, &decoded)
+		require.NoError(t, err)
+		assert.Equal(t, sr.UsersLastUpdateAt, decoded.UsersLastUpdateAt)
+		assert.Equal(t, sr.UserErrors, decoded.UserErrors)
+	})
+}