upstream/upstream-centrifugo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

snapshot of https://github.com/centrifugal/centrifugo.git (master, 2026-09-16; blobs > 131072B omitted)
Some checks failed
test / Lint (push) Failing after 3s
Details
test / Test with Go 1.26.8 (push) Failing after 2s
Details

Browse Source
This commit is contained in:
upstream-mirror
2026-09-16 01:17:21 +05:00
commit b352a9a30d
472 changed files with 108375 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
internal/proxyproto/shared_poll_test.go Normal file
View File

@@ -0,0 +1,199 @@
package proxyproto
import (
"encoding/json"
"testing"
"github.com/stretchr/testify/require"
)
func TestEncodeSharedPollRefreshRequest(t *testing.T) {
encoder := &JSONEncoder{}
req := &SharedPollRefreshRequest{
Channel: "test:channel",
Items: []*SharedPollRefreshItem{
{Key: "key1", Version: 0},
{Key: "key2", Version: 5},
},
}
data, err := encoder.EncodeSharedPollRefreshRequest(req)
require.NoError(t, err)
var decoded map[string]interface{}
err = json.Unmarshal(data, &decoded)
require.NoError(t, err)
require.Equal(t, "test:channel", decoded["channel"])
items := decoded["items"].([]interface{})
require.Len(t, items, 2)
item0 := items[0].(map[string]interface{})
require.Equal(t, "key1", item0["key"])
// Version 0 should be omitted (omitempty).
_, hasVersion := item0["version"]
require.False(t, hasVersion)
item1 := items[1].(map[string]interface{})
require.Equal(t, "key2", item1["key"])
require.Equal(t, float64(5), item1["version"])
}
func TestEncodeSharedPollRefreshRequest_EmptyItems(t *testing.T) {
encoder := &JSONEncoder{}
req := &SharedPollRefreshRequest{
Channel: "ch",
Items: []*SharedPollRefreshItem{},
}
data, err := encoder.EncodeSharedPollRefreshRequest(req)
require.NoError(t, err)
require.Contains(t, string(data), `"channel":"ch"`)
}
func TestDecodeSharedPollRefreshResponse(t *testing.T) {
decoder := &JSONDecoder{}
input := `{
"result": {
"items": [
{"key": "key1", "data": {"votes": 42}, "version": 5},
{"key": "key2", "data": {"votes": 10}, "version": 3, "removed": true}
]
}
}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(input))
require.NoError(t, err)
require.NotNil(t, resp.Result)
require.Len(t, resp.Result.Items, 2)
item0 := resp.Result.Items[0]
require.Equal(t, "key1", item0.Key)
require.Equal(t, uint64(5), item0.Version)
require.False(t, item0.Removed)
require.Contains(t, string(item0.Data), "42")
item1 := resp.Result.Items[1]
require.Equal(t, "key2", item1.Key)
require.Equal(t, uint64(3), item1.Version)
require.True(t, item1.Removed)
}
func TestDecodeSharedPollRefreshResponse_EmptyItems(t *testing.T) {
decoder := &JSONDecoder{}
input := `{"result": {"items": []}}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(input))
require.NoError(t, err)
require.NotNil(t, resp.Result)
require.Empty(t, resp.Result.Items)
}
func TestDecodeSharedPollRefreshResponse_MissingFields(t *testing.T) {
decoder := &JSONDecoder{}
input := `{"result": {"items": [{"key": "key1"}]}}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(input))
require.NoError(t, err)
require.Len(t, resp.Result.Items, 1)
item := resp.Result.Items[0]
require.Equal(t, "key1", item.Key)
require.Equal(t, uint64(0), item.Version)
require.False(t, item.Removed)
require.Nil(t, item.Data)
require.Nil(t, item.PrevData)
}
func TestDecodeSharedPollRefreshResponse_WithPrevData(t *testing.T) {
decoder := &JSONDecoder{}
input := `{"result": {"items": [{"key": "k1", "data": {"v": 1}, "version": 2, "prev_data": {"v": 0}}]}}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(input))
require.NoError(t, err)
require.Len(t, resp.Result.Items, 1)
require.NotNil(t, resp.Result.Items[0].PrevData)
require.Contains(t, string(resp.Result.Items[0].PrevData), "0")
}
func TestDecodeSharedPollRefreshResponse_ErrorResponse(t *testing.T) {
decoder := &JSONDecoder{}
input := `{"error": {"code": 100, "message": "internal error"}}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(input))
require.NoError(t, err)
require.NotNil(t, resp.Error)
require.Equal(t, uint32(100), resp.Error.Code)
require.Equal(t, "internal error", resp.Error.Message)
require.Nil(t, resp.Result)
}
func TestDecodeSharedPollRefreshResponse_NullResult(t *testing.T) {
decoder := &JSONDecoder{}
input := `{"result": null}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(input))
require.NoError(t, err)
require.Nil(t, resp.Result)
}
func TestDecodeSharedPollRefreshResponse_InvalidJSON(t *testing.T) {
decoder := &JSONDecoder{}
_, err := decoder.DecodeSharedPollRefreshResponse([]byte(`not json`))
require.Error(t, err)
}
func TestSharedPollRefreshRequest_RoundTrip(t *testing.T) {
encoder := &JSONEncoder{}
decoder := &JSONDecoder{}
original := &SharedPollRefreshRequest{
Channel: "test:ch",
Items: []*SharedPollRefreshItem{
{Key: "k1", Version: 10},
{Key: "k2", Version: 0},
{Key: "k3", Version: 999},
},
}
data, err := encoder.EncodeSharedPollRefreshRequest(original)
require.NoError(t, err)
// Wrap in response format to test decode.
respJSON := `{"result": {"items": [{"key": "k1", "data": {"x": 1}, "version": 11}, {"key": "k3", "data": {"x": 3}, "version": 1000}]}}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(respJSON))
require.NoError(t, err)
require.Len(t, resp.Result.Items, 2)
// Verify the request was encoded properly.
var reqDecoded SharedPollRefreshRequest
err = json.Unmarshal(data, &reqDecoded)
require.NoError(t, err)
require.Equal(t, "test:ch", reqDecoded.Channel)
require.Len(t, reqDecoded.Items, 3)
}
func TestEncodeSharedPollRefreshRequest_DiffMode(t *testing.T) {
encoder := &JSONEncoder{}
req := &SharedPollRefreshRequest{
Channel: "ch",
Items: []*SharedPollRefreshItem{
{Key: "k1", Version: 5},
{Key: "k2", Version: 10},
},
}
data, err := encoder.EncodeSharedPollRefreshRequest(req)
require.NoError(t, err)
var decoded map[string]interface{}
err = json.Unmarshal(data, &decoded)
require.NoError(t, err)
items := decoded["items"].([]interface{})
item0 := items[0].(map[string]interface{})
require.Equal(t, float64(5), item0["version"])
item1 := items[1].(map[string]interface{})
require.Equal(t, float64(10), item1["version"])
}
func TestDecodeSharedPollRefreshResponse_RemovedItem(t *testing.T) {
decoder := &JSONDecoder{}
input := `{"result": {"items": [{"key": "k1", "removed": true}]}}`
resp, err := decoder.DecodeSharedPollRefreshResponse([]byte(input))
require.NoError(t, err)
require.Len(t, resp.Result.Items, 1)
require.True(t, resp.Result.Items[0].Removed)
require.Equal(t, "k1", resp.Result.Items[0].Key)
require.Equal(t, uint64(0), resp.Result.Items[0].Version)
}