Expose public/ API as submodule (#23345)

* model -> public/model

* plugin -> public/plugin

* public/model/utils -> public/utils

* platform/shared/mlog -> public/shared/mlog

* platform/shared/i18n -> public/shared/i18n

* platform/shared/markdown -> public/shared/markdown

* platform/services/timezones -> public/shared/timezones

* channels/einterfaces -> einterfaces

* expose public/ submodule

* go mod tidy

* .github: cache-dependency-path, setup-go-work

* modules-tidy for public/ too

* remove old gomodtidy

server/public/model/integration_action_test.go

@@ -0,0 +1,157 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"encoding/base64"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTriggerIdDecodeAndVerification(t *testing.T) {
+	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	require.NoError(t, err)
+
+	t.Run("should succeed decoding and validation", func(t *testing.T) {
+		userId := NewId()
+		clientTriggerId, triggerId, appErr := GenerateTriggerId(userId, key)
+		require.Nil(t, appErr)
+		decodedClientTriggerId, decodedUserId, appErr := DecodeAndVerifyTriggerId(triggerId, key)
+		assert.Nil(t, appErr)
+		assert.Equal(t, clientTriggerId, decodedClientTriggerId)
+		assert.Equal(t, userId, decodedUserId)
+	})
+
+	t.Run("should succeed decoding and validation through request structs", func(t *testing.T) {
+		actionReq := &PostActionIntegrationRequest{
+			UserId: NewId(),
+		}
+		clientTriggerId, triggerId, appErr := actionReq.GenerateTriggerId(key)
+		require.Nil(t, appErr)
+		dialogReq := &OpenDialogRequest{TriggerId: triggerId}
+		decodedClientTriggerId, decodedUserId, appErr := dialogReq.DecodeAndVerifyTriggerId(key)
+		assert.Nil(t, appErr)
+		assert.Equal(t, clientTriggerId, decodedClientTriggerId)
+		assert.Equal(t, actionReq.UserId, decodedUserId)
+	})
+
+	t.Run("should fail on base64 decode", func(t *testing.T) {
+		_, _, appErr := DecodeAndVerifyTriggerId("junk!", key)
+		require.NotNil(t, appErr)
+		assert.Equal(t, "interactive_message.decode_trigger_id.base64_decode_failed", appErr.Id)
+	})
+
+	t.Run("should fail on trigger parsing", func(t *testing.T) {
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("junk!")), key)
+		require.NotNil(t, appErr)
+		assert.Equal(t, "interactive_message.decode_trigger_id.missing_data", appErr.Id)
+	})
+
+	t.Run("should fail on expired timestamp", func(t *testing.T) {
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:1234567890:junksignature")), key)
+		require.NotNil(t, appErr)
+		assert.Equal(t, "interactive_message.decode_trigger_id.expired", appErr.Id)
+	})
+
+	t.Run("should fail on base64 decoding signature", func(t *testing.T) {
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:12345678900000:junk!")), key)
+		require.NotNil(t, appErr)
+		assert.Equal(t, "interactive_message.decode_trigger_id.base64_decode_failed_signature", appErr.Id)
+	})
+
+	t.Run("should fail on bad signature", func(t *testing.T) {
+		_, _, appErr := DecodeAndVerifyTriggerId(base64.StdEncoding.EncodeToString([]byte("some-trigger-id:some-user-id:12345678900000:junk")), key)
+		require.NotNil(t, appErr)
+		assert.Equal(t, "interactive_message.decode_trigger_id.signature_decode_failed", appErr.Id)
+	})
+
+	t.Run("should fail on bad key", func(t *testing.T) {
+		_, triggerId, appErr := GenerateTriggerId(NewId(), key)
+		require.Nil(t, appErr)
+		newKey, keyErr := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+		require.NoError(t, keyErr)
+		_, _, appErr = DecodeAndVerifyTriggerId(triggerId, newKey)
+		require.NotNil(t, appErr)
+		assert.Equal(t, "interactive_message.decode_trigger_id.verify_signature_failed", appErr.Id)
+	})
+}
+
+func TestPostActionIntegrationEquals(t *testing.T) {
+	t.Run("equal uncomparable types", func(t *testing.T) {
+		pa1 := &PostAction{
+			Integration: &PostActionIntegration{
+				Context: map[string]any{
+					"a": map[string]any{
+						"a": 0,
+					},
+				},
+			},
+		}
+		pa2 := &PostAction{
+			Integration: &PostActionIntegration{
+				Context: map[string]any{
+					"a": map[string]any{
+						"a": 0,
+					},
+				},
+			},
+		}
+		require.True(t, pa1.Equals(pa2))
+	})
+
+	t.Run("equal comparable types", func(t *testing.T) {
+		pa1 := &PostAction{
+			Integration: &PostActionIntegration{
+				Context: map[string]any{
+					"a": "test",
+				},
+			},
+		}
+		pa2 := &PostAction{
+			Integration: &PostActionIntegration{
+				Context: map[string]any{
+					"a": "test",
+				},
+			},
+		}
+		require.True(t, pa1.Equals(pa2))
+	})
+
+	t.Run("non-equal types", func(t *testing.T) {
+		pa1 := &PostAction{
+			Integration: &PostActionIntegration{
+				Context: map[string]any{
+					"a": map[string]any{
+						"a": 0,
+					},
+				},
+			},
+		}
+		pa2 := &PostAction{
+			Integration: &PostActionIntegration{
+				Context: map[string]any{
+					"a": "test",
+				},
+			},
+		}
+		require.False(t, pa1.Equals(pa2))
+	})
+
+	t.Run("nil check", func(t *testing.T) {
+		pa1 := &PostAction{
+			Integration: &PostActionIntegration{},
+		}
+
+		pa2 := &PostAction{
+			Integration: nil,
+		}
+
+		require.False(t, pa1.Equals(pa2))
+	})
+}